Permalink
Browse files

Init project

  • Loading branch information...
0 parents commit 8768db2fb1b707c779b825c22c3ae61d4e2fa37a @ihower ihower committed Jul 22, 2010
2 .gitignore
@@ -0,0 +1,2 @@
+output/*.html
+.DS_Store
12 README.textile
@@ -0,0 +1,12 @@
+h1. "ruby-lang.org/zh_TW":http://ruby-lang.org/zh_TW
+
+The original content is from "http://ruby-lang.org":http://ruby-lang.org (using "Rediant CMS":http://radiantcms.org/)
+
+h2. USAGE
+
+type "ruby generate.rb" will generate HTML to /output
+
+h2. zh-TW site maintainers
+
+* SJH
+* ihower
133 about.textile
@@ -0,0 +1,133 @@
+Wondering why Ruby is so popular? Its fans call it a beautiful, artful language. And yet, they say it's handy and practical. What gives?
+
+h3. The Ideals of Ruby's Creator
+
+!>{padding-left:8px}http://redhanded.hobix.com/images/ruby-lang-matz.png!
+
+Ruby is a language of careful balance. Its creator, <a href="http://www.rubyist.net/~matz/">Yukihiro "matz" Matsumoto</a>, blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.
+
+He has often said that he is "trying to make Ruby natural, not simple," in a way that mirrors life.
+
+Building on this, he adds:
+
+bq. Ruby is simple in appearance, but is very complex inside, just like our human body[1].
+
+h3. About Ruby's Growth
+
+Since its public release in 1995, Ruby has drawn devoted coders worldwide. In 2006, Ruby achieved mass acceptance. With active user groups formed in the world's major cities and Ruby-related conferences filled to capacity.
+
+!>{padding-left:8px}http://gmane.org/plot-rate.php?group=gmane.comp.lang.ruby.general&width=280&height=140&title=Ruby-Talk+Activity+over+4+Years(Graph courtesy of Gmane.)!
+
+Ruby-Talk, the primary "mailing list":/en/community/mailing-lists/ for discussion of the Ruby language has climbed to an average of 200 messages per day.
+
+The TIOBE index, which measures the growth of programming languages, ranks Ruby as #9 among programming languages worldwide. Much of the growth is attributed to the popularity of software written in Ruby, particularly the Ruby on Rails web framework[2].
+
+Ruby is also "totally free":./license.txt. Not only free of charge, but also free to use, copy, modify, and distribute.
+
+h3. Seeing Everything as an Object
+
+Initially, Matz looked at other languages to find an ideal syntax. Recalling his search, he said, "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python[3]."
+
+In Ruby, everything is an object. Every bit of information and code can be given their own properties and actions. Object-oriented programming calls properties by the name _instance variables_ and actions are known as _methods_. Ruby's pure object-oriented approach is most commonly demonstrated by a bit of code which applies an action to a number.
+
+<notextile><r:code>
+5.times { print "We *love* Ruby -- it's outrageous!" }
+</r:code></notextile>
+
+In many languages, numbers and other primitive types are not objects. Ruby follows the influence of the Smalltalk language by giving methods and instance variables to all of its types. This eases one's use of Ruby, since rules applying to objects apply to all of Ruby.
+
+h3. Ruby's Flexibility
+
+Ruby is seen as a flexible language, since it allows its users to freely alter its parts. Essential parts of Ruby can be removed or redefined, at will. Existing parts can be added upon. Ruby tries not to restrict the coder.
+
+For example, addition is performed with the plus (@+@) operator. But, if you'd rather use the readable word @plus@, you could add such a method to Ruby's builtin @Numeric@ class.
+
+<notextile><r:code>
+class Numeric
+ def plus(x)
+ self.+(x)
+ end
+end
+
+y = 5.plus 6
+# y is now equal to 11
+</r:code></notextile>
+
+Ruby's operators are syntactic sugar for methods. You can redefine them as well.
+
+h3. Blocks, a Truly Expressive Feature
+
+Ruby's block are also seen as a source of great flexibility. A programmer can attach a closure to any method, describing how that method should act. The closure is called a _block_ and has become one of the most popular features for newcomers to Ruby from other imperative languages like PHP or Visual Basic.
+
+Blocks are inspired by functional languages. Matz said, "in Ruby closures, I wanted to respect the Lisp culture[4]."
+
+<notextile><r:code>
+search_engines =
+ %w[Google Yahoo MSN].map do |engine|
+ "http://www." + engine.downcase + ".com"
+ end
+</r:code></notextile>
+
+In the above code, the block is described inside the @do ... end@ construct. The @map@ method applies the block to the provided list of words. Many other methods in Ruby leave a hole open for a coder to write their own block to fill in the details of what that method should do.
+
+h3. Ruby and the Mixin
+
+Unlike many object-oriented languages, Ruby features single inheritance only, *on purpose*. But Ruby knows the
+concept of modules (called Categories in Objective-C). Modules are collections
+of methods.
+
+Classes can mixin a module and receive all its methods for free. For example, any class which implements the @each@ method can mixin the @Enumerable@ module, which adds a pile of methods that use @each@ for looping.
+
+<notextile><r:code>
+class MyArray
+ include Enumerable
+end
+</r:code></notextile>
+
+Generally, Rubyists see this as a much clearer way than multiple inheritance, which is complex and can be too restrictive.
+
+h3. Ruby's Visual Appearance
+
+While Ruby often uses very limited punctuation and usually prefers English keywords, some punctuation is used to decorate Ruby.
+Ruby needs no variable declarations. It uses simple naming conventions to
+denote the scope of variables.
+
+* @var@ could be a local variable.
+* @@var@ is an instance variable.
+* @$var@ is a global variable.
+
+These sigils enhance readability by allowing the programmer to easily identify the roles of each variable. It also becomes unnecessary to use a tiresome @self.@ prepended to every instance member.
+
+h3. Beyond the Basics
+
+Ruby has a wealth of other features, among which are the following:
+
+* Ruby has exception handling features, like Java or Python, to make it easy to
+handle errors.
+
+* Ruby features a true mark-and-sweep garbage collector for all Ruby
+objects. No need to maintain reference counts in extension
+libraries. As Matz says, "This is better for your health."
+
+* Writing C extensions in Ruby is easier than in Perl or Python, with a very elegant
+API for calling Ruby from C. This includes calls for embedding Ruby in software, for use
+as a scripting language. A SWIG interface is also available.
+
+* Ruby can load extension libraries dynamically if an OS allows.
+
+* Ruby features OS independent threading. Thus, for all platforms on which Ruby
+runs, you also have multithreading, regardless of if the OS supports it or not,
+even on MS-DOS!
+
+* Ruby is highly portable: it is developed mostly on GNU/Linux, but works on many
+types of UNIX, Mac OS X, Windows 95/98/Me/NT/2000/XP, DOS, BeOS, OS/2, etc.
+
+h4. References
+
+fn1. Matz, speaking on the Ruby-Talk mailing list, "May 12th, 2000":http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/2773.
+
+fn2. See the "Ruby on Rails":http://rubyonrails.org/ home page for more.
+
+fn3. Matz, in "An Interview with the Creator of Ruby":http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html, Nov. 29th, 2001.
+
+fn4. Matz, in "Blocks and Closures in Ruby":http://www.artima.com/intv/closures2.html, December 22nd, 2003.
129 about.zh_TW.textile
@@ -0,0 +1,129 @@
+想知道Ruby為何如此受歡迎嗎? 為什麼它的支持者會稱它是個美麗、靈巧而且方便又實用的程式語言?
+
+h3. Ruby 發明者的理想
+
+!>{padding-left:8px}http://redhanded.hobix.com/images/ruby-lang-matz.png!
+
+Ruby 是一個注重均衡的語言. 它的發明者, <a href="http://www.rubyist.net/~matz/">松本行弘 Yukihiro "matz" Matsumoto</a>, 混合了他喜歡的語言 (如 Perl, Smalltalk, Eiffel, Ada, and Lisp) 產生了一個具有函數式與指令式程式設計語言特性的新語言。
+
+他常說他是: "試著讓 Ruby 更為自然,而不是簡單”,就像生活一樣。
+
+除此之外, 他還提到:
+
+bq. Ruby 就像人的身體一樣,表面上看來簡單,但是內在卻是相當的複雜,[1].
+
+h3. Ruby 的成長
+
+自從在 1995 年公開發表以來, Ruby 在全球吸引了許多忠實的程式設計師. 在 2006 年, Ruby 被廣泛的接受. 在各大城市都有活躍的使用者社群並舉辦了許許多多場場爆滿的研討會.
+
+!>{padding-left:8px}http://gmane.org/plot-rate.php?group=gmane.comp.lang.ruby.general&width=280&height=140&title=Ruby-Talk+Activity+over+4+Years(Graph courtesy of Gmane.)!
+
+在主要的 "郵件論壇: Ruby-Talk":/en/community/mailing-lists/ 上,討論 Ruby 語言的文章爬升到每日 200 封.
+
+在 "TIOBE 的最流行開發語言排名調查":http://www.tiobe.com/index.htm?tiobe_index中, Ruby 排名為全球第 11. 根據這樣的成長情況, 他們預測 "在半年之中 Ruby 將會進入最受歡迎的第 10 名." 有越來越多受歡迎的軟體如 Ruby on Rails web framework[2] 是使用 Ruby 撰寫而成,也是造成了 Ruby 如此的成長因素.
+
+同時,Ruby 是個"自由軟體":/zh_TW/about/license.txt. 不只是免費,而且可以自由的使用, 修改與散佈.
+
+h3. 所見即物件
+
+最初,Matz 從其他語言中找尋理想的語法。 想起他做的研究,他說:"我想要一個比 Perl 更強大,比 Python 更物件導向的 scripting language [3]".
+
+
+在 Ruby 中,所有的東西都是個物件。所有的資訊與程式碼都可以給與他們所擁有的 屬性(properties) 與 行為(actions) 。物件導向程式設計中稱屬性為 _實體變數_(_instance variables_) 而行為稱為 _方法_(_methods_)。從下列程式碼中看到 Ruby 能夠給 "數字(number)" 賦予 "行為(actions)" 這特點來看,可以證明 Ruby 是個純物件導向的語言。
+
+
+<notextile><r:code>
+5.times { print "We *love* Ruby -- it's outrageous!" }
+</r:code></notextile>
+
+在許多的語言中,數字與其他的原生資料型態(primitive types) 都不是物件。 而 Ruby 受到了 Smalltalk 語言讓所有的資料型態都可賦予方法與產生實體變數的影響。更進而讓這規則適用於 Ruby 中所有物件。
+
+
+h3. Ruby 的彈性
+
+Ruby 是個相當具有彈性的語言, 它可以讓使用者自由的去改變它的本身。 Ruby 的必要部份也可以隨意地被移除或重新定義。已存在的部份也可以被繼續添加內容。Ruby 試著不去限制程式設計人員。
+
+
+舉例而言,我們使用 (@+@) 運算元來執行加法。但是如果你打算使用 @plus@ 來取代,你可以加入以下的方法到 Ruby 的內建 @Numeric@ 類別之中。
+
+
+<notextile><r:code>
+class Numeric
+ def plus(x)
+ self.+(x)
+ end
+end
+
+y = 5.plus 6
+# y is now equal to 11
+</r:code></notextile>
+
+Ruby 的運算元其實就是個方法(method)[4]。你也可以重新定義運算元。
+
+h3. 區塊(Blocks), 很有意思的功能
+
+Ruby 的區塊可說是它強大彈性的來源。 程式設計師可以為任何的 method 加上 closure(閉包) , 來描述這個 method 該做什麼。此處的 closure 稱為 _block_ 同時這也是從指令式程式設計語言如 PHP 或 Visual Basic 轉換到 Ruby 的新手最喜歡的功能。
+
+Block 的靈感是由函數式程式設計語言而來。Matz 說到:"在 Ruby closures 之中, 我要向 Lisp culture 致敬[5]."
+
+<notextile><r:code>
+search_engines =
+ %w[Google Yahoo MSN].map do |engine|
+ "http://www." + engine.downcase + ".com"
+ end
+</r:code></notextile>
+
+在上方的程式碼中,block 是在 @do ... end@ 之間。其中 @map@ method 提供一個字串陣列給 block。Ruby 中還有許多其他的 methods 提供了類似的方式可以讓程式設計師撰寫自己的 block 來完成此 method 該做的事。
+
+h3. Ruby 與 Mixin
+
+和其他許多的物件導向語言不同,Ruby 故意的只提供 單一繼承(single inheritance)。但是 Ruby 提供 模組(module) 的觀念(在 Objective-C 中稱為 Categories)。
+Module 是許多 method 的集合。
+
+類別(Class) 可以 混入(mixin) 模組並且可以自由的取用模組內的所有方法。舉例而也,所有要實作 @each@ 方法的類別都可以 混入 @Enumerable@ 模組進來,就可以使用 @each@ 方法來達到執行迴圈的目的。
+
+<notextile><r:code>
+class MyArray
+ include Enumerable
+end
+</r:code></notextile>
+
+一般來說,Ruby 使用者使用這種方式會比使用複雜且有很多限制的多重繼承來得清楚。
+
+h3. Ruby 的面貌
+
+Ruby 常使用某些符號與英文關鍵字來輔助撰寫程式。Ruby 不需要事先宣告變數。它使用簡單的命名規則來說明變數的生命範圍。
+
+* @var@ 表示變數是個 區域變數(local variable).
+* @@var@ 表示變數是個 實體變數(instance variable).
+* @$var@ 表示變數是個 全域變數(global variable).
+
+這些符號讓程式設計師可以輕易的定義每個變數的角色進而增加了程式的易讀性。另外 Ruby 也省略了累贅的 @self.@ 方便直接來存取每個實體成員。
+
+h3. 更上一層樓
+
+Ruby 還具有以下的特點:
+
+* Ruby 具有 例外處理(exception handling) 的能力。就如 Java 或 Python 一樣,可以讓使用者輕鬆的處理錯誤狀況。
+
+* Ruby 對於所有的物件具有一個真正的 標記-清除(mark and sweep) 式的垃圾收集器(garbage collector)。使用者不必去維護擴充函式庫中的 參考計數器(reference counts)。如 Matz說的:"這樣有益健康"。
+
+* 在 Ruby 中撰寫 C 的擴充程式比在 Perl 或 Python 中方便,它擁有許多方便的 API 可以讓 C 呼叫 Ruby。這樣可以將 Ruby 當成 script language 嵌入到其他軟體之中。它也具有 SWIG 的呼叫界面。
+
+* 如果作業系統支援,Ruby 可以動態的載入擴充函式庫。
+
+* Ruby 具有與作業系統無關的多緒(threading)能力。可以在所有可以執行 Ruby 的平台上都能夠達到多緒的目標,而不必管作業系統是否支援,就算是 MS-DOS 也行。
+
+* Ruby 具有高度的移植性:它大部份是在 GUN/Linux 上發展出來,但是可以執行於多種的作業系統如: UNIX, MAC OS X,Windows 95/98/Me/NT/2000/XP, DOS, BeOS, OS/2, 等等。
+
+h4. 參考資料
+
+fn1. Matz, 於 Ruby-Talk 郵件論壇上的發言, "May 12th, 2000":http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/2773.
+
+fn2. 請參考 "Ruby on Rails":http://rubyonrails.org/ 官方首頁有更多資料.
+
+fn3. Matz, in "An Interview with the Creator of Ruby":http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html, Nov. 29th, 2001.
+
+fn4. 原文直譯:運算元是方法的語法糖衣(syntactic sugar),Ruby's operators are syntactic sugar for methods.
+
+fn5. Matz, in "Blocks and Closures in Ruby":http://www.artima.com/intv/closures2.html, December 22nd, 2003.
31 community.conferences.textile
@@ -0,0 +1,31 @@
+Ruby programmers around the world are getting involved in more and more conferences, where they get together to share reports on work-in-progress, discuss the future of Ruby, and welcome newcomers to the Ruby community.
+
+h3. Major Ruby Conferences
+
+<dl>
+<dt>"RubyConf":http://rubyconf.org/</dt>
+<dd>Every year since 2001, "Ruby Central, Inc.":http://www.rubycentral.org has produced RubyConf, the International Ruby conference. Attendance grew by a factor of ten between 2001 and 2006. RubyConf has provided a forum for presentations about Ruby technologies by their creators, including talks by Nathaniel Talbot on Test Unit, Jim Weirich on Rake, David Heinemeier Hansson on Ruby on Rails, Why the Lucky Stiff on the YAML library, and Sasada Koichi on YARV. Matz has attended, and spoken
+at, all the RubyConfs but one.</dd>
+
+<dt>"RubyKaigi":http://jp.rubyist.net/RubyKaigi2008/</dt>
+<dd>The first Japanese Ruby conference, RubyKaigi 2006, took place in Odaiba. RubyKaigi provides many new and exciting talks by Matz and other Rubyists in every year.</dd>
+
+<dt>"EuRuKo <small>(Europaeische Ruby Konferenz)</small>":http://www.approximity.com/cgi-bin/europeRuby/tiki.cgi?c=v&p=Euruko07</dt>
+<dd>The first annual European Ruby Conference (EuRuKo) was held in Karlsruhe, Germany, in 2003. Organized by a team of German Rubyists including Armin Roehrl and Michael Neumann, EuRuKo emerged as the second annual Ruby event, starting two years after RubyConf.</dd>
+
+<dt>"Open Source Developer Conference":http://www.osdc.com.au/</dt>
+<dd>This is an annual open source development conference that is held each year in Australia. While not specifically a Ruby conference, each year we do get a number of Ruby papers and we are always interested in more Ruby content.</dd>
+</dl>
+
+h3. Regional Ruby Conferences
+
+"Ruby Central":http://www.rubycentral.org administers a "Regional Conference Grant Program":http://www.rubycentral.org/rcg2006.pdf, to offset expenses for local and regional groups wanting to organize events.</p>
+
+Ruby Central has also teamed up with "SDForum":http://www.sdforum.org to produce the Silicon Valley
+Ruby Conference, entering its second year in 2007.
+
+"RubyNation":http://rubynation.org/ is an annual Ruby conference serving the Virginia, West Virginia, Maryland, and Washington, DC areas.
+
+h3. Ruby At Other Conferences
+
+There has been a Ruby track at the "O'Reilly Open Source Conference":http://conferences.oreillynet.com/os2006/ (OSCON) since 2004, and an increasing presence on the part of Ruby and Rubyists at other non-Ruby-specific gatherings. A number of conferences have also been devoted to "Ruby on Rails":http://www.rubyonrails.org, including Ruby Central's "RailsConf":http://www.railsconf.org, "RailsConf Europe":http://europe.railsconf.org (co-produced in 2006 by Ruby Central and "Skills Matter":http://www.skillsmatter.com, and in 2007 by Ruby Central and O'Reilly), and Canada on Rails.
76 community.ruby-core.textile
@@ -0,0 +1,76 @@
+Now is a fantastic time to follow Ruby's development, with Ruby 2.0 development underway. With the increased attention Ruby has received in the past few years, there's a growing need for good talent to help enhance Ruby and document its parts. So, where do you start?
+
+The topics related to Ruby development covered here are:
+
+* "Using Subversion to Track Ruby Development":#following-ruby
+* "How to Use Git With the Main Ruby Repository":#git-ruby
+* "Improving Ruby, Patch by Patch":#patching-ruby
+* and, "Rules for Core Developers":#coding-standards
+
+h3. <a name="following-ruby"></a>Using Subversion to Track Ruby Development
+
+Checking out the latest Ruby source code is a matter of logging into the "Subversion":http://subversion.tigris.org/ anonymous account. From your commandline:
+
+<code><pre>
+ $ svn co http://svn.ruby-lang.org/repos/ruby/trunk ruby
+</pre></code>
+
+The @ruby@ directory will now contain the latest source code for Ruby 1.9 (trunk), which is the development version of Ruby. The trunk was used to release a stable 1.9.1 version in January 2009. Currently patches applied to the trunk are backported to the stable 1_9_1 branch (see below).
+
+If you'd like to follow patching of Ruby 1.9.1, you should use the @ruby_1_9_1@ branch when checking out:
+
+<code><pre>
+ $ svn co http://svn.ruby-lang.org/repos/ruby/branches/ruby_1_9_1
+</pre></code>
+
+If you'd like to follow patching of Ruby 1.8, you should use the @ruby_1_8_6@ or @ruby_1_8_7@ branch when checking out (depending on the version you're using):
+
+<code><pre>
+ $ svn co http://svn.ruby-lang.org/repos/ruby/branches/ruby_1_8_7
+</pre></code>
+
+This will check out the Ruby 1.8.7 development tree into a @ruby_1_8_7@ directory. Developers working on Ruby 1.8 are expected to migrate their changes to Ruby's trunk, so often the two branches are very similiar, with the exception of improvements made by Matz and Nobu to the language itself.
+
+If you prefer, you may browse "Ruby's repository via the web":http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/.
+
+For information about Subversion, please see "the Subversion FAQ":http://subversion.tigris.org/faq.html and "the Subversion book":http://svnbook.org. Alternatively, you may find "Pragmatic Version Control with Subversion":http://www.pragmaticprogrammer.com/titles/svn/ to be a useful introductory book.
+
+h3. <a name="git-ruby"></a>How to Use Git With the Main Ruby Repository
+
+Those who prefer to use "Git":http://git-scm.com/ over Subversion can find instructions with "the mirror on GitHub":http://github.com/shyouhei/ruby, both for "those with commit access":http://wiki.github.com/shyouhei/ruby/committerhowto and "everybody else":http://wiki.github.com/shyouhei/ruby/noncommitterhowto.
+
+h3. <a name="patching-ruby"></a>Improving Ruby, Patch by Patch
+
+The core team maintains "a bug tracker":http://redmine.ruby-lang.org/ for submitting patches and bug reports to Matz and the gang. These reports also get submitted to the "Ruby-Core mailing list":/en/community/mailing-lists/#ruby-core for discussion, so you can be sure your request won't go unnoticed. You can also send your patches straight to the mailing list. Either way, you are encouraged to take part in the discussion that ensues.
+
+Please look over the "Patch Writer's Guide":http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/25139 for some tips, straight from matz, on how to get your patches considered.
+
+To summarize, the steps for building a patch are:
+
+# If you are fixing a bug in Ruby 1.8, check out a copy of Ruby 1.8 from Subversion using the @ruby_1_8@ branch.<code><pre>
+ $ svn co http://svn.ruby-lang.org/repos/ruby/branches/ruby_1_8
+</code></pre>If you wish to add a feature to Ruby, check out the trunk of Ruby's source. Even if you wish to add a feature to Ruby 1.8, it has to be proven in the trunk first.<code><pre>
+ $ svn co http://svn.ruby-lang.org/repos/ruby/trunk ruby
+</code></pre>
+# Add your improvements to the code.
+# Create a patch.<code><pre>
+ $ svn diff > ruby-changes.patch
+</pre></code>
+# Email your patch to the "Ruby-Core mailing list":/en/community/mailing-lists/#ruby-core with a CHANGELOG entry describing the patch.
+# If there are no issues raised about the patch, committers will be given the approval to apply it.
+
+*Please note:* patches should be submitted as a "unified diff":http://www.gnu.org/software/diffutils/manual/html_node/Unified-Format.html. For more on how patches are merged, see "the diffutils reference":http://www.gnu.org/software/diffutils/manual/html_node/Merging-with-patch.html#Merging%20with%20patch.
+
+Discussion of Ruby's development converges on the "Ruby-Core mailing list":/en/community/mailing-lists/#ruby-core. So, if you are curious about whether your patch is worthwhile or you want to spark a discussion about Ruby's future, don't hesitate to come aboard. Be warned that off-topic discussions are not tolerated on this list, the noise level should be very low, topics should be pointed, well-conceived and well-written. Since we're addressing Ruby's creator, let's have some reverence.
+
+Keep in mind that Ruby's core developers live in Japan and, while many speak very good English, there is a significant timezone difference. They also have an entire body of Japanese development lists happening alongside the English counterparts. Be patient, if your claim isn't resolved, be persistent -- give it another shot a few days later.
+
+h3. <a name="coding-standards"></a>Rules for Core Developers
+
+Generally, the developers of Ruby should be familiar with the source code and the style of development used by the team. To be clear, the following guidelines should be honored when checking into Subversion:
+
+* All check-ins should be described in the @ChangeLog@, following the "GNU conventions":http://www.gnu.org/prep/standards/standards.html#Change-Logs. (Many Ruby core developers use Emacs @add-log@ mode, which can be accessed with the command @C-x 4 a@.)
+* Check-in dates should be given in Japan Standard Time (UTC+9).
+* The bulleted points from your ChangeLog should also be placed in the Subversion commit message. This message will be automatically mailed to the Ruby-CVS list after you commit.
+* K&R function declarations are used throughout Ruby's source code and its packaged extensions.
+* Please, do not use C++-style comments (@//@), Ruby's maintainers instead prefer the standard C multiline comment. (@/* .. */@)
36 community.textile
@@ -0,0 +1,36 @@
+The community that grows up around a programming language is one of its most important strengths. Ruby has a vibrant and growing community that is friendly towards people of all skill levels.
+
+If you are interested in getting involved, here are a couple of places to start:
+
+<dl>
+<dt>"Ruby User Groups":user-groups/</dt>
+<dd>Your local Ruby user group is a great place to network with other Ruby programmers. Ruby user groups are self-organizing and typically feature monthly meetings, a mailing list, a Web site, and if you are lucky, frequent codefests.</dd>
+
+<dt>"Ruby Mailing Lists and Newsgroups":mailing-lists/</dt>
+<dd>Ruby has an assortment of lists on different topics and in several languages. If you have questions about Ruby, asking them on a mailing list is a great way to get answers.</dd>
+
+<dt>"Ruby on IRC":irc://irc.freenode.net/ruby-lang</dt>
+<dd>The Ruby Language IRC Channel is a wonderful way to chat with fellow Rubyists. ("Previous Chat Logs":http://meme.b9.com/)
+</dd>
+
+<dt>"Ruby Core":ruby-core/</dt>
+<dd>With Ruby 2.0 underway, now is a fantastic time to be following Ruby's development. If you are interested in helping with Ruby, start here.</dd>
+
+<dt>"Weblogs About Ruby":weblogs/</dt>
+<dd>Very little happens in the Ruby community that is not talked about on the blogs. We've got a nice list of suggestions for you here for getting plugged in.</dd>
+
+<dt>"Ruby Conferences":conferences/</dt>
+<dd>Ruby programmers around the world are getting involved in more and more conferences, where they get together to share reports on work-in-progress, discuss the future of Ruby, and welcome newcomers to the Ruby community.</dd>
+
+<dt>"The Ruby Mentor Project":http://rubymentor.rubyforge.org/</dt>
+<dd>This new resource aims to pair people new to Ruby with more experienced guides. The goal is to ease the process of learning Ruby by having someone you can ask questions of. This is intended to be a little less intimidating than a mailing list, though Ruby Talk does welcome questions from beginners.</dd>
+
+<dt>General Ruby Information</dt>
+<dd>
+<ul>
+<li>"Ruby Central":http://www.rubycentral.org/</li>
+<li>"Ruby at Open Directory Project":http://dmoz.org/Computers/Programming/Languages/Ruby/</li>
+<li>"Rails at Open Directory Project":http://dmoz.org/Computers/Programming/Languages/Ruby/Software/Rails/</li>
+</ul>
+</dd>
+</dl>
32 community.weblogs.textile
@@ -0,0 +1,32 @@
+Ruby blogs have exploded over the past year and, given sufficient hunting, you can unearth hundreds of blogs sharing bits of Ruby code, describing new techniques, or speculating on Ruby's future.
+
+h3. Mining for Ruby Blogs
+
+"*Ruby on del.icio.us*":http://del.icio.us/tag/ruby: Ruby and Rails are consistently one of the top fifty tags on del.icio.us, a popular link sharing site. Watch the "ruby":http://del.icio.us/tag/ruby tag for incoming obscure links and its "popularity chart":http://del.icio.us/popular/ruby for recent upcomers in the Ruby community.
+
+!>http://technorati.com/chartimg/%28ruby%29?totalHits=391174&size=s&days=30(30-day graph of activity for 'ruby' among blogs on Technorati.)!
+
+"*Ruby on Technorati*":http://technorati.com/search/ruby: Technorati's search for _"Ruby"_ yields the most recent posts across the blogs covered in its index.
+
+*Planets*: some planets (online specialized feeds agregators) have been running for years now. A few of them providing convenient content:
+* "Ruby Corner":http://rubycorner.com
+* "Planet Ruby":http://planetruby.0x42.net/
+* "PlanetRubyOnRails.org":http://www.planetrubyonrails.org/
+* "PlanetRubyOnRails.com":http://www.planetrubyonrails.com/
+
+h3. Blogs of Note
+
+A few notable blogs stand out for the frequency and immediacy of their updates.
+
+* "*O'Reilly Ruby*":http://oreillynet.com/ruby/ is a group blog with pertinent Ruby tutorials and interviews with interesting folks from around the community.
+* "*Riding Rails*":http://weblog.rubyonrails.org/ is the official group blog of the Ruby on Rails team. If you are running Rails, this blog is essential for notification of security updates and an overall view of the wide Rails community.
+* "*Ruby Inside*":http://www.rubyinside.com/ announces interesting applications and libraries from throughout the world, both Ruby and Rails.
+* "*Matz' Blog*":http://www.rubyist.net/~matz/ is a Japanese blog written by Ruby's creator. Even if you can't read all of it, it's good to know he's right there!
+* "*Rails Envy*":http://railsenvy.com/ is a blog and podcast where you can learn a lot about what's going on in Rails and just plain Ruby. They have a good video collection too, where you can fast-forward through popular Ruby events or just be entertained.
+* "*Ruby Web Developer news group*":http://newsforwhatyoudo.com/groups/643ddee01cd911deaef1001aa018681c/news is a new type of collaborative news site / feed reader where Rubyists discover, filter and comment on news that's relevant to their profession.
+
+h3. Spreading the Word
+
+If you've got a Ruby blog you've started, it's wise to link the blog on "del.icio.us":http://del.icio.us with the _ruby_ tag. You might also contact the weblogs above, if you are covering a topic they'd be interested in. (Obviously, if it's not Rails-related, then the _Riding Rails_ crew may not be as interested -- but you never know.)
+
+Ruby is also a common topic on both "Digg":http://digg.com/programming and "Slashdot":http://developers.slashdot.org/, in their respective programming news. If you find some brilliant code out there, be sure to let them know!
118 documentation.quickstart.textile
@@ -0,0 +1,118 @@
+h2. Introduction
+
+This is a small Ruby tutorial that should take no more than 20 minutes to
+complete. It makes the assumption that you already have Ruby installed.
+(If you don't have Ruby on your computer "download":/en/downloads/ and
+install it before you get started.)
+
+h2. Interactive Ruby
+
+Ruby comes with a program that will show the results of any Ruby statements you feed it. Playing with Ruby code in interactive sessions like this is a terrific way to learn the language.
+
+Open up IRB (which stands for Interactive Ruby).
+
+* If you're using *Mac OS X* open up @Terminal@ and type
+@irb@, then hit enter.
+* If you're using *Linux*, open up a shell and type
+@irb@ and hit enter.
+* If you're using *Windows*, open @fxri@ from the Ruby section of your Start Menu.
+
+<notextile><r:code>
+irb(main):001:0>
+</r:code></notextile>
+
+Ok, so it's open. Now what?
+
+Type this: @"Hello World"@
+
+<notextile><r:code>
+irb(main):001:0> "Hello World"
+=> "Hello World"
+</r:code></notextile>
+
+h2. Ruby Obeyed You!
+
+What just happened? Did we just write the world's shortest "Hello
+World" program? Not exactly. The second line is just IRB's way of
+telling us the result of the last expression it evaluated. If we want
+to print out "Hello World" we need a bit more:
+
+<notextile><r:code>
+irb(main):002:0> puts "Hello World"
+Hello World
+=> nil
+</r:code></notextile>
+
+@puts@ is the basic command to print something out in Ruby. But then what's the
+@=> nil@ bit? That's the result of the expression. @puts@ always
+returns nil, which is Ruby's absolutely-positively-nothing value.
+
+h2. Your Free Calculator is Here
+
+Already, we have enough to use IRB as a basic calculator:
+
+<notextile><r:code>
+irb(main):003:0> 3+2
+=> 5
+</r:code></notextile>
+
+Three plus two. Easy enough. What about three _times_ two? You could
+type it in, it's short enough, but you may also be able to go up and
+change what you just entered. Try hitting the *up-arrow* on your
+keyboard and see if it brings up the line with @3+2@ on it. If it
+does, you can use the left arrow key to move just after the @+@ sign
+and then use backspace to change it to a @*@ sign.
+
+<notextile><r:code>
+irb(main):004:0> 3*2
+=> 6
+</r:code></notextile>
+
+Next, let's try three squared:
+
+<notextile><r:code>
+irb(main):005:0> 3**2
+=> 9
+</r:code></notextile>
+
+In Ruby @**@ is the way you say "to the power of". But what if you
+want to go the other way and find the square root of something?
+
+<notextile><r:code>
+irb(main):006:0> Math.sqrt(9)
+=> 3.0
+</r:code></notextile>
+
+Ok, wait, what was that last one? If you guessed, "it was figuring out
+the square root of nine," you're right. But let's take a closer
+look at things. First of all, what's @Math@?
+
+h2. Modules, Group Code by Topic
+
+@Math@ is a built-in module for mathematics. Modules serve two roles in
+Ruby. This shows one role: grouping similar methods together under a familiar
+name. @Math@ also contains methods like @sin()@ and @tan()@.
+
+Next is a dot. What does the dot do? The dot is how you identify the
+receiver of a message. What's the message? In this case it's
+@sqrt(9)@, which means call the method @sqrt@, shorthand for "square
+root" with the parameter of @9@.
+
+The result of this method call is the value @3.0@. You might notice
+it's not just @3@. That's because most of the time the square root of
+a number won't be an integer, so the method always returns a
+floating-point number.
+
+What if we want to remember the result of some of this math? Assign
+the result to a variable.
+
+<notextile><r:code>
+irb(main):007:0> a = 3 ** 2
+=> 9
+irb(main):008:0> b = 4 ** 2
+=> 16
+irb(main):009:0> Math.sqrt(a+b) => 5.0
+</r:code></notextile>
+
+As great as this is for a calculator, we’re getting away from the traditional
+@Hello World@ message that beginning tutorials are supposed to focus on… "so let’s go back to that.":2/
429 documentation.ruby-from-other-languages.textile
@@ -0,0 +1,429 @@
+When you first look at some Ruby code, it will likely remind you of other
+programming languages you've used. This is on purpose. Much of the
+syntax is familiar to users of Perl, Python, and Java (among other
+languages), so if you've used those, learning Ruby will be a piece of cake.
+
+This document contains two major sections. The first attempts
+to be a rapid-fire summary of what you can expect to see when going
+from language _X_ to Ruby. The second section tackles the major
+language features and how they might compare to what you're already
+familiar with.
+
+h2. What to Expect: _Language X_ to Ruby
+<r:children:each by="title">
+* <r:link /></r:children:each>
+
+h2. Important Language Features And Some Gotchas
+
+Here are some pointers and hints on major Ruby features you'll
+see while learning Ruby.
+
+h3. Iteration
+
+Two Ruby features that are a bit unlike what you may have seen before,
+and which take some getting used to, are "blocks" and iterators. Instead
+of looping over an index (like with C, C++, or pre-1.5 Java),
+or looping over a list (like Perl's <tt>for (@a) {...}</tt>, or Python's
+<tt>for i in aList: ...</tt>), with Ruby you'll very often instead see
+
+<notextile><r:code>
+some_list.each do |this_item|
+ # We're inside the block.
+ # deal with this_item.
+end
+</r:code></notextile>
+
+For more info on @each@ (and it's friends @collect@, @find@, @inject@, @sort@, etc.),
+see @ri Enumerable@ (and then <tt>ri Enumerable#<i>func_name</i></tt>).
+
+h3. Everything has a value
+
+There's no difference between an expression and a statement. Everything has a value,
+even if that value is *nil*. This is possible:
+
+<notextile><r:code>
+x = 10
+y = 11
+z = if x < y
+ true
+else
+ false
+end
+z # => true
+</r:code></notextile>
+
+h3. Symbols are not lightweight Strings
+
+Many Ruby newbies struggle with understanding what Symbols are, and what they can
+be used for.
+
+Symbols can best be described as identities. A symbol is all about *who* it is,
+not *what* it is. Fire up <code>irb</code> and see the difference:
+
+<notextile><r:code>
+irb(main):001:0> :george.object_id == :george.object_id
+=> true
+irb(main):002:0> "george".object_id == "george".object_id
+=> false
+irb(main):003:0>
+</r:code></notextile>
+
+The <code>object_id</code> methods returns the identity of an Object. If two
+objects have the same <code>object_id</code>, they are the same (point to the
+same Object in memory).
+
+As you can see, once you have used a Symbol once, any Symbol with the same
+characters references the same Object in memory. For any given two Symbols that
+represent the same characters, the <code>object_id</code>s match.
+
+Now take a look at the String ("george"). The <code>object_id</code>s don't
+match. That means they're referencing two different objects in memory.
+Whenever you use a new String, Ruby allocates memory for it.
+
+If you're in doubt whether to use a Symbol or a String, consider what's more
+important: the identity of an object (i.e. a Hash key), or the contents (in
+the example above, "george").
+
+
+h3. Everything is an Object
+
+"Everything is an object" isn't just hyperbole. Even classes and integers are
+objects, and you can do the same things with them as with any other object:
+
+<notextile><r:code>
+# This is the same as
+# class MyClass
+# attr_accessor :instance_var
+# end
+MyClass = Class.new do
+ attr_accessor :instance_var
+end
+</r:code></notextile>
+
+
+h3. Variable Constants
+
+Constants are not really constant. If you modify an already initialized constant,
+it will trigger a warning, but not halt your program. That isn't to say you
+*should* redefine constants, though.
+
+
+
+h3. Naming conventions
+
+Ruby enforces some naming conventions. If an identifier starts with a capital letter,
+it is a constant. If it starts with a dollar sign ($), it is a global variable. If
+it starts with <code>@</code>, it is an instance variable. If it starts with <code>@@</code>,
+it is a class variable.
+
+Method names, however, are allowed to start with capital letters. This can lead to
+confusion, as the example below shows:
+
+<notextile><r:code>
+Constant = 10
+def Constant
+ 11
+end
+</r:code></notextile>
+
+Now <code>Constant</code> is 10, but <code>Constant()</code> is 11.
+
+
+
+h3. Fake keyword parameters
+
+Ruby doesn't have keyword parameters, like Python has. However, it can be faked by
+using symbols and hashes. Ruby on Rails, among others, uses this heavily. Example:
+
+<notextile><r:code>
+def some_keyword_params( params )
+ params
+end
+some_keyword_params( :param_one => 10, :param_two => 42 )
+# => {:param_one=>10, :param_two=>42}
+</r:code></notextile>
+
+h3. The universal truth
+
+In Ruby, everything except *nil* and *false* is considered true. In C, Python and
+many other languages, 0 and possibly other values, such as empty lists, are consided
+false. Take a look at the following Python code (the example applies to other languages,
+too):
+
+<notextile><r:code>
+# in Python
+if 0:
+ print "0 is true"
+else:
+ print "0 is false"
+</r:code></notextile>
+
+This will print "0 is false". The equivalent Ruby:
+
+<notextile><r:code>
+# in Ruby
+if 0
+ puts "0 is true"
+else
+ puts "0 is false"
+end
+</r:code></notextile>
+
+Prints "0 is true".
+
+
+
+h3. Access modifiers apply until the end of scope
+
+In the following Ruby code,
+
+<notextile><r:code>
+class MyClass
+ private
+ def a_method; true; end
+ def another_method; false; end
+end
+</r:code></notextile>
+
+You might expect <code>another_method</code> to be public. Not so. The 'private' access
+modifier continues until the end of the scope, or until another access modifier
+pops up, whichever comes first. By default, methods are public:
+
+<notextile><r:code>
+class MyClass
+ # Now a_method is public
+ def a_method; true; end
+
+ private
+
+ # another_method is private
+ def another_method; false; end
+end
+</r:code></notextile>
+
+<code>public</code>, <code>private</code> and <code>protected</code> are really methods,
+so they can take parameters. If you pass a Symbol to one of them, that method's visibility
+is altered.
+
+
+
+h3. Method access
+
+<p>In Java, <code>public</code> means a method is accessible by anyone. <code>protected</code>
+means the class's instances, instances of descendant classes, and instances of classes in the same package
+can access it, but not anyone else, and <code>private</code> means nobody besides the classes instances
+can access the method.</p>
+
+Ruby differs slightly. <code>public</code> is, naturally, public. <code>private</code> means
+the method(s) are accessible only when they can be called without an explicit receiver. Only *self* is
+allowed to be the receiver of a private method call.
+
+<code>protected</code> is the one to be on the lookout for. A protected method can be called
+from a class or descendant class instances, but also with another instance as its receiver.
+
+Example, adapted from the "Ruby FAQ":http://faq.rubygarden.org/entry/show/57?controller_prefix=faq%2F:
+
+<notextile><r:code>
+$ irb
+irb(main):001:0> class Test
+irb(main):002:1> # public by default
+irb(main):003:1* def func
+irb(main):004:2> 99
+irb(main):005:2> end
+irb(main):006:1>
+irb(main):007:1* def ==(other)
+irb(main):008:2> func == other.func
+irb(main):009:2> end
+irb(main):010:1> end
+=> nil
+irb(main):011:0>
+irb(main):012:0* t1 = Test.new
+=> #<Test:0x34ab50>
+irb(main):013:0> t2 = Test.new
+=> #<Test:0x342784>
+irb(main):014:0> t1 == t2
+=> true
+irb(main):015:0> # now make `func` protected, still works
+irb(main):016:0* # because protected allows the other reference
+irb(main):017:0* class Test
+irb(main):018:1> protected :func
+irb(main):019:1> end
+=> Test
+irb(main):020:0> t1 == t2
+=> true
+irb(main):021:0> # now make `func` private
+irb(main):022:0* class Test
+irb(main):023:1> private :func
+irb(main):024:1> end
+=> Test
+irb(main):025:0> t1 == t2
+NoMethodError: private method `func' called for #<Test:0x342784>
+ from (irb):8:in `=='
+ from (irb):25
+ from :0
+irb(main):026:0>
+</r:code></notextile>
+
+
+
+h3. Classes are open
+
+Ruby classes are open. You can open them up, add to them, and change them
+at any time. Even core classes, like <code>Fixnum</code> or even
+<code>Object</code>, the parent of all objects. Ruby on Rails defines a
+bunch of methods for dealing with time on <code>Fixnum</code>. Watch:
+
+<notextile><r:code>
+class Fixnum
+ def hours
+ self * 3600 # number of seconds in an hour
+ end
+ alias hour hours
+end
+
+# 14 hours from 00:00 January 1st
+# (aka when you finally wake up ;)
+Time.mktime(2006, 01, 01) + 14.hours # => Sun Jan 01 14:00:00
+</r:code></notextile>
+
+
+
+h3. Funny method names
+
+In Ruby, methods are allowed to end with question marks or exclamation marks.
+By convention, methods that answer questions (i.e. <tt>Array#empty?</tt>
+returns *true* if the receiver is empty) end in question marks. Potentially
+"dangerous" methods (ie methods that modify *self* or the arguments,
+<code>exit!</code> etc.) by convention end with exclamation marks.
+
+All methods that change their arguments don't end with exclamation marks,
+though. <tt>Array#replace</tt> replaces the contents of an array with the contents
+of another array. It doesn't make much sense to have a method like that
+that *doesn't* modify self.
+
+
+
+h3. Singleton methods
+
+Singleton methods are per-object methods. They are only available on the
+Object you defined it on.
+
+<notextile><r:code>
+class Car
+ def inspect
+ "Cheap car"
+ end
+end
+
+porsche = Car.new
+porsche.inspect # => Cheap car
+def porsche.inspect
+ "Expensive car"
+end
+
+porsche.inspect # => Expensive car
+
+# Other objects are not affected
+other_car = Car.new
+other_car.inspect # => Cheap car
+</r:code></notextile>
+
+
+h3. Missing methods
+
+Ruby doesn't give up if it can't find a method that responds to a particular
+message. It calls the <code>method_missing</code> method with the name of the method
+it couldn't find and the arguments. By default, method_missing raises a
+NameError exception, but you can redefine it to better fit your application,
+and many libraries do. Here is an example:
+
+<notextile><r:code>
+# id is the name of the method called, the * syntax collects
+# all the arguments in an array named 'arguments'
+def method_missing( id, *arguments )
+ puts "Method #{id} was called, but not found. It has " +
+ "these arguments: #{arguments.join(", ")}"
+end
+
+__ :a, :b, 10
+# => Method __ was called, but not found. It has these
+# arguments: a, b, 10
+</r:code></notextile>
+
+The code above just prints the details of the call, but you are free to handle the message in any way that is appropriate.
+
+
+
+h3. Message passing, not function calls
+
+A method call is really a *message* to another object:
+
+<notextile><r:code>
+# This
+1 + 2
+# Is the same as this ...
+1.+(2)
+# Which is the same as this:
+1.send "+", 2
+</r:code></notextile>
+
+h3. Blocks are Objects, they just don't know it yet
+
+Blocks (closures, really) are heavily used by the standard library. To call a
+block, you can either use @yield@, or make it a @Proc@ by appending a special
+argument to the argument list, like so:
+
+<notextile><r:code>
+def block( &the_block )
+ # Inside here, the_block is the block passed to the method
+ the_block # return the block
+end
+adder = block { |a, b| a + b }
+# adder is now a Proc object
+adder.class # => Proc
+</r:code></notextile>
+
+You can create blocks outside of method calls, too, by calling Proc.new with
+a block or calling the <code>lambda</code> method.
+
+Similarly, methods are also Objects in the making:
+
+<notextile><r:code>
+method(:puts).call "puts is an object!"
+# => puts is an object!
+</r:code></notextile>
+
+h3. Operators are syntactic sugar
+
+Most operators in Ruby are just syntactic sugar (with some precedence rules) for method calls. You can, for example, override Fixnums + method:
+
+<notextile><r:code>
+class Fixnum
+ # You can, but please don't do this
+ def +( other )
+ self - other
+ end
+end
+</r:code></notextile>
+
+You don't need C++'s <code>operator+</code>, etc.
+
+You can even have array-style access if you define the <code>[]</code> and <code>[]=</code>
+methods. To define the unary + and - (think +1 and -2), you must define the
+<code>+@</code> and <code>-@</code> methods, respectively.
+
+The operators below are *not* syntactic sugar, though. They are not methods,
+and cannot be redefined:
+
+<notextile><r:code lang="symbols">
+=, .., ..., !, not, &&, and, ||, or, !=, !~, ::
+</r:code></notextile>
+
+In addition, +=, *= etc. are just abbrevations for
+<code>var = var + other_var</code>, <code>var = var * other_var</code>, etc. and therefore
+cannot be redefined.
+
+
+h2. Finding Out More
+
+When you are ready for more Ruby knowledge, see our "Documentation":/en/documentation/ section.
148 documentation.ruby-from-other-languages.to-ruby-from-c-and-c-.textile
@@ -0,0 +1,148 @@
+It's difficult to write a bulleted list describing how your code
+will be different in Ruby from C or C++ because it's quite a large
+difference. One reason is that the Ruby runtime does so much for you.
+Ruby seems about as far as you can get from C's "no hidden mechanism"
+principle -- the whole point of Ruby is to make the human's job easier
+at the expense of making the runtime shoulder more of the work. Unless
+or until you profile your code for optimization, you don't need to
+care one whit about "keeping your compiler happy" when using Ruby.
+
+That said, for one thing, you can expect your Ruby code to execute
+much more slowly than "equivalent" C or C++ code. At the same time,
+your head will spin at how rapidly you can get a Ruby program up and
+running, as well as at how few lines of code it will take to write it.
+Ruby is much much simpler than C++ -- it will spoil you rotten.
+
+Ruby is dynamically typed, rather than statically typed -- the
+runtime does as much as possible at run-time. For example, you don't
+need to know what modules your Ruby program will "link to" (that is,
+load and use) or what methods it will call ahead of time.
+
+Happily, it turns out that Ruby and C have a healthy symbiotic
+relationship. Ruby supports so-called "extension modules". These
+are modules that you can use from your Ruby programs (and which,
+from the outside, will look and act just like any other Ruby module),
+but which are written in C. In this way, you can compartmentalize the
+performance-critical parts of your Ruby software, and smelt
+those down to pure C.
+
+And, of course, Ruby itself is written in C.
+
+
+
+h3. Similarities with C
+
+As with C, in Ruby,...
+* You may program procedurally if you like (but it will still
+be object-oriented behind the scenes).
+* Most of the operators are the same (including the compound
+assignment and also bitwise operators). Though, Ruby doesn't
+have @++@ or @--@.
+* You've got @__FILE__@ and @__LINE__@.
+* You can also have constants, though there's no special @const@
+keyword. Const-ness is enforced by a naming convention instead --
+names starting with a capital letter are for constants.
+* Strings go in double-quotes.
+* Strings are mutable.
+* Just like man pages, you can read most docs in your
+terminal window -- though using the @ri@ command.
+* You've got the same sort of command-line debugger available.
+
+
+
+h3. Similarities with C++
+
+As with C++, in Ruby,...
+* You've got mostly the same operators (even @::@). @<<@ is often used
+for appending elements to a list. One note though: with Ruby you never
+use @->@ -- it's always just @.@.
+* @public@, @private@, and @protected@ do similar jobs.
+* Inheritance syntax is still only one character, but it's @<@
+instead of @:@.
+* You may put your code into "modules", similar to how @namespace@
+in C++ is used.
+* Exceptions work in a similar manner, though the keyword names have
+been changed to protect the innocent.
+
+
+
+h3. Differences from C
+
+Unlike C, in Ruby,...
+* Objects are strongly typed (and variable names themselves
+have no type at all).
+* There's no macros or preprocessor. No casts. No pointers
+(nor pointer arithmetic). No typedefs, sizeof, nor enums.
+* There are no header files. You just define your functions (usually
+referred to as "methods") and classes in the main source code files.
+* There's no <tt>#define</tt>. Just use constants instead.
+* As of Ruby 1.8, code is interpreted at run-time rather than compiled to
+any sort of machine- or byte-code.
+* All variables live on the heap. Further, you don't need to free
+them yourself -- the garbage collector takes care of that.
+* Arguments to methods (i.e. functions) are passed by reference,
+not by value.
+* It's @require 'foo'@ instead of @#include <foo>@ or @#include "foo"@.
+* You cannot drop down to assembly.
+* There's no semicolon's ending lines.
+* You go without parentheses for @if@ and @while@ condition expressions.
+* Parentheses for method (i.e. function) calls are often optional.
+* You don't usually use braces -- just end multi-line constructs
+(like @while@ loops) with an @end@ keyword.
+* The @do@ keyword is for so-called "blocks". There's no "do statement"
+like in C.
+* The term "block" means something different. It's for a block of
+code that you associate with a method call so the method body can
+call out to the block while it executes.
+* There are no variable declarations. You just assign to new names
+on-the-fly when you need them.
+* When tested for truth, only @false@ and @nil@ evaluate to a false value.
+Everything else is true (including @0@, @0.0@, and @"0"@).
+* There is no @char@ -- they are just 1-letter strings.
+* Strings don't end with a null byte.
+* Array literals go in brackets instead of braces.
+* Arrays just automatically get bigger when you stuff more elements into them.
+* If you add two arrays, you get back a new and bigger array (of
+course, allocated on the heap) instead of doing pointer arithmetic.
+* More often than not, everything is an expression (that is, things
+like @while@ statements actually evaluate to an rvalue).
+
+
+
+
+h3. Differences from C++
+
+Unlike C++, in Ruby,...
+* There's no explicit references. That is, in Ruby, every variable
+is just an automatically dereferenced name for some object.
+* Objects are strongly but _dynamically_ typed. The runtime
+discovers _at runtime_ if that method call actually works.
+* The "constructor" is called @initialize@ instead of the class
+name.
+* All methods are always virtual.
+* "Class" (static) variable names always begin with <tt>@@</tt>
+(as in <tt>@@total_widgets</tt>).
+* You don't directly access member variables -- all
+access to public member variables (known in Ruby as attributes)
+is via methods.
+* It's @self@ instead of @this@.
+* Some methods end in a '?' or a '!'. It's actually part of the
+method name.
+* There's no multiple inheritance per se. Though Ruby has "mixins"
+(i.e. you can "inherit" all instance methods of a module).
+* There are some enforced case-conventions (ex. class names start
+with a capital letter, variables start with a lowercase letter).
+* Parentheses for method calls are usually optional.
+* You can re-open a class anytime and add more methods.
+* There's no need of C++ templates (since you can assign any
+kind of object to a given variable, and types get figured out
+at runtime anyway). No casting either.
+* Iteration is done a bit differently. In Ruby, you don't use a separate iterator object
+(like @vector<T>::const_iterator iter@) but instead your objects
+may mixin the @Enumerator@ module and just make a method call like @my_obj.each@.
+* There's only two container types: @Array@ and @Hash@.
+* There's no type conversions. With Ruby though, you'll probably find
+that they aren't necessary.
+* Multithreading is built-in, but as of Ruby 1.8 they are "green threads"
+(implemented only within the interpreter) as opposed to native threads.
+* A unit testing lib comes standard with Ruby.
42 documentation.ruby-from-other-languages.to-ruby-from-java.textile
@@ -0,0 +1,42 @@
+Java is mature. It's tested. And it's fast (contrary to what the anti-Java crowd may
+still claim). It's also quite verbose. Going from Java to Ruby, expect your code size
+to shrink down considerably. You can also expect it to take less time to knock together
+quick prototypes.
+
+h3. Similarities
+
+As with Java, in Ruby,...
+* Memory is managed for you via a garbage collector.
+* Objects are strongly typed.
+* There are public, private, and protected methods.
+* There are embedded doc tools (Ruby's is called RDoc). The docs generated by rdoc look
+very similar to those generated by javadoc.
+
+h3. Differences
+
+Unlike Java, in Ruby,...
+* You don't need to compile your code. You just run it directly.
+* There are different GUI toolkits. Ruby users can try
+"WxRuby":http://wxruby.rubyforge.org/wiki/wiki.pl,
+"FXRuby":http://www.fxruby.org/,
+"Ruby-GNOME2":http://ruby-gnome2.sourceforge.jp/,
+or the bundled-in Ruby Tk for example.
+* You use the @end@ keyword after defining things like classes, instead of having
+to put braces around blocks of code.
+* You have @require@ instead of @import@.
+* All member variables are private. From the outside, you access everything via methods.
+* Parentheses in method calls are usually optional and often omitted.
+* Everything is an object, including numbers like 2 and 3.14159.
+* There's no static type checking.
+* Variable names are just labels. They don't have a type associated
+with them.
+* There are no type declarations. You just assign to new variable names as-needed
+and they just "spring up" (i.e. @a = [1,2,3]@ rather than @int[] a = {1,2,3};@).
+* There's no casting. Just call the methods. Your unit tests should tell you
+before you even run the code if you're going to see an exception.
+* It's @foo = Foo.new( "hi")@ instead of @Foo foo = new Foo( "hi" )@.
+* The constructor is always named "initialize" instead of the name of the class.
+* You have "mixin's" instead of interfaces.
+* YAML tends to be favored over XML.
+* It's @nil@ instead of @null@.
+* @==@ and @equals()@ are handled differently in Ruby. Use @==@ when you want to test equivalence in Ruby (@equals()@ is Java). Use @equal?()@ when you want to know if two objects are the same (@==@ in Java).
50 documentation.ruby-from-other-languages.to-ruby-from-perl.textile
@@ -0,0 +1,50 @@
+Perl is awesome. Perl's docs are awesome. The Perl community is ...
+awesome. However, the language is fairly large and arguably complex.
+For those Perlers who long for a simpler time, a more orthogonal language,
+and elegant OO features built-in from the beginning, Ruby may be for you.
+
+h3. Similarities
+
+As with Perl, in Ruby,...
+* You've got a package management system, somewhat like CPAN (though it's called
+"RubyGems":http://docs.rubygems.org/)
+* Regexes are built right in. Bon app&eacute;tit!
+* There's a fairly large number of commonly-used built-ins.
+* Parentheses are often optional
+* Strings work basically the same.
+* There's a general delimited string and regex quoting syntax
+similar to Perl's (looks like @%q{this (single-quoted)}@, or @%Q{this (double-quotish)}@, and
+@%w{this for a single-quoted list of words}@. You @%Q|can|@ @%Q(use)@ @%Q^other^@ delimiters if you like).
+* You've got double-quotish variable interpolation, though it
+@"looks #{like} this"@ (and you can put any Ruby code you like inside
+that @#{}@).
+* Shell command expansion uses `backticks`.
+* You've got embedded doc tools (Ruby's is called rdoc).
+
+h3. Differences
+
+Unlike Perl, in Ruby,...
+* You don't have the context-dependent rules like with Perl.
+* A variable isn't the same as the object to which it refers. Instead, it's
+always just a reference to an object.
+* Although @$@ and <tt>@</tt> are used as the first character in variable names sometimes, rather than
+indicating type, they indicate scope (@$@ for globals, <tt>@</tt> for object instance, and
+<tt>@@</tt> for class attributes).
+* Array literals go in brackets instead of parentheses.
+* Composing lists of other lists does not flatten them into one big list.
+Instead you get an array of arrays.
+* It's @def@ instead of @sub@.
+* There's no semicolons needed at the end of each line. Incidentally, you end things like
+function definitions, class definitions, and case statements with the @end@ keyword.
+* Objects are strongly typed. You'll be manually calling @foo.to_i@, @foo.to_s@, etc.,
+if you need to convert between types.
+* There's no @eq@, @ne@, @lt@, @gt@, @ge@, nor @le@.
+* There's no diamond operator. You usually use <tt>IO.<i>some_func</i></tt> instead.
+* The fat comma is only used for hash literals.
+* There's no @undef@. In Ruby you have @nil@. @nil@ is an object (like anything else
+in Ruby). It's not the same as an undefined variable. It evaluates to @false@ if you
+treat it like a boolean.
+* When tested for truth, only @false@ and @nil@ evaluate to a false value. Everything else
+is true (including @0@, @0.0@, and @"0"@).
+* There's no "PerlMonks":http://www.perlmonks.org/. Though the ruby-talk mailing
+list is a very helpful place.
39 documentation.ruby-from-other-languages.to-ruby-from-php.textile
@@ -0,0 +1,39 @@
+PHP is in widespread use for web applications, but if you want to use Ruby on Rails
+or just want a language that's more tailored for general use, Ruby is worth a look.
+
+h3. Similarities
+
+As in PHP, in Ruby...
+* Ruby is dynamically typed, like in PHP, so you don't need to worry about having to
+declare variables.
+* There are classes, and you can control access to them like in PHP 5 (@public@,
+@protected@ and @private@)
+* Some variables start with $, like in PHP (but not all)
+* There's @eval@, too.
+* You can use string interpolating. Instead of doing "$foo is a $bar", you can do
+"#{foo} is a #{bar}" -- like in PHP, this doesn't apply for single-quoted strings.
+* There's heredocs
+* Ruby has exceptions, like PHP 5
+* There's a fairly large standard library
+* Arrays and hashes work like expected, if you exchange @array()@ for @{@ and @}@:
+@array('a' => 'b')@ becomes @{'a' => 'b'}@.
+* @true@ and @false@ behave like in PHP, but @null@ is called @nil@
+
+h3. Differences
+
+Unlike in PHP, in Ruby...
+* There's strong typing. You'll need to call @to_s@, @to_i@ etc. to convert between
+strings, integers and so on, instead of relying on the language to do it
+* Strings, numbers, arrays, hashes, etc. are objects. Instead of calling abs(-1)
+it's -1.abs
+* Parentheses are optional in method calls, except to clarify which parameters go to
+which method calls
+* Instead of naming conventions, like underscores, the standard library and extensions
+are organized in modules and classes
+* Reflection is an inherent capability of objects, you don't need to use @Reflection@
+classes like in PHP 5
+* Variables are references.
+* There's no @abstract@ classes or <code>interface</code>s
+* Hashes and arrays are not interchangeable
+* Only @false@ and @nil@ are false: @0@, @array()@ and @""@ are all true in conditionals.
+* Almost everything is a method call, even @raise@ (@throw@ in PHP).
55 documentation.ruby-from-other-languages.to-ruby-from-python.textile
@@ -0,0 +1,55 @@
+Python is another very nice general purpose programming language.
+Going from Python to Ruby, you'll find that there's a little bit more
+syntax to learn than with Python.
+
+h3. Similarities
+
+As with Python, in Ruby,...
+* There's an interactive prompt (called @irb@).
+* You can read docs on the command line (with the @ri@ command instead
+of @pydoc@).
+* There are no special line terminators (except the usual newline).
+* String literals can span multiple lines like Python's triple-quoted
+strings.
+* Brackets are for lists, and braces are for dicts (which, in Ruby, are called
+"hashes").
+* Arrays work the same (adding them makes one long array, but composing
+them like this @a3 = [ a1, a2 ]@ gives you an array of arrays).
+* Objects are strongly and dynamically typed.
+* Everything is an object, and variables are just references to objects.
+* Although the keywords are a bit different, exceptions work about the same.
+* You've got embedded doc tools (Ruby's is called rdoc).
+
+
+h3. Differences
+
+Unlike Python, in Ruby,...
+* Strings are mutable.
+* You can make constants (variables whose value you don't intend to change).
+* There are some enforced case-conventions (ex. class names start
+with a capital letter, variables start with a lowercase letter).
+* There's only one kind of list container (an Array), and it's mutable.
+* Double-quoted strings allow escape sequences (like \t) and
+a special "expression substitution" syntax (which allows you to insert
+the results of Ruby expressions directly into other strings without
+having to @"add " + "strings " + "together"@). Single-quoted strings
+are like Python's @r"raw strings"@.
+* There are no "new style" and "old style" classes. Just one kind.
+* You never directly access attributes. With Ruby, it's all method calls.
+* Parentheses for method calls are usually optional.
+* There's @public@, @private@, and @protected@ to enforce access, instead
+of Python's @_voluntary_@ underscore @__convention__@.
+* "mixin's" are used instead of multiple inheritance.
+* You can add or modify the methods of built-in classes. Both languages let you open up and modify classes at any point, but Python prevents modification of built-ins &mdash; Ruby does not.
+* You've got @true@ and @false@ instead of @True@ and @False@ (and @nil@
+instead of @None@).
+* When tested for truth, only @false@ and @nil@ evaluate to a false value.
+Everything else is true (including @0@, @0.0@, @""@, and @[]@).
+* It's @elsif@ instead of @elif@.
+* It's @require@ instead of @import@. Otherwise though, usage is the same.
+* The usual-style comments on the line(s) _above_ things (instead of
+docstrings below them) are used for generating docs.
+* There are a number of shortcuts that, although give you more to
+remember, you quickly learn. They tend to make Ruby fun and very
+productive.
+
42 documentation.success-stories.textile
@@ -0,0 +1,42 @@
+Many people use Ruby in their daily jobs. Others just as a hobby. Here you'll find a small sample of real world usage of Ruby.
+
+
+h4. Simulations
+
+* "NASA Langley Research Center":http://www.larc.nasa.gov/ uses Ruby to conduct simulations.
+
+* A research group in "Motorola":http://www.motorola.com uses Ruby to script a simulator, both to generate scenarios and to post process the data.
+
+h4. 3D Modeling
+
+* "Google SketchUp":http://www.sketchup.com/ is a 3D modeling application that uses Ruby for its macro scripting API.
+
+h4. Business
+
+* "Toronto Rehab":http://www.torontorehab.on.ca/ uses a RubyWebDialogs based app to manage and track on-call and on-site support for the IT help desk and IT operations teams.
+
+h4. Robotics
+
+* At "MORPHA":http://www.morpha.de/php_e/ project, Ruby was used to implemented the reactive control part for the Siemens service robot.
+
+h4. Networking
+
+* "Open Domain Server":http://ods.org/ uses Ruby to allow people using Dynamic DNS clients to update in real time their IP configuration so that it can be mapped to static domains.
+
+h4. Telephony
+
+* Ruby is being used within "Lucent":http://www.lucent.com/ on a 3G wireless telephony product.
+
+h4. System Administration
+
+* Ruby was used to write the central data collection portion of "Level 3 Communications":http://www.level3.com/ Unix Capacity and Planning system that gathers performance statistics from over 1700 Unix (Solaris and Linux) servers scattered around the globe.
+
+h4. Web Applications
+
+* "Basecamp":http://www.basecamphq.com, a web-based project management application developed by "37signals":http://www.37signals.com, is programmed entirely in Ruby.
+
+* "43 Things":http://www.43things.com allows you to keep a list of goals and share it with the world. It was developed entirely in Ruby.
+
+* "A List Apart":http://www.alistapart.com, a magazine for people who make websites that has been around since 1997, has recently been revamped and uses a custom application built with Ruby on Rails.
+
+* "Blue Sequence":http://www.bluefountain.com/casestudies/bfs-deliver-a-2nd-sequence-production-system-for-toyota/, a sophisticated mission-critical application which forms part of Toyota Motor Manufacturing's own "sequence-in-time" production process, has recently been selected as finalist the British Computer (BCS) Information Management Awards.
66 documentation.textile
@@ -0,0 +1,66 @@
+Here you will find pointers to manuals, tutorials and references that will come in handy when you feel like coding in Ruby.
+
+h3. Getting Started
+
+<dl>
+<dt>"Learn to Program":http://pine.fm/LearnToProgram/</dt>
+<dd>A wonderful little tutorial by Chris Pine for programming newbies. If you don't know how to program, start here.</dd>
+
+<dt>"Ruby in Twenty Minutes":/en/documentation/quickstart/</dt>
+<dd>A nice tutorial covering the basics of Ruby. From start to finish it shouldn't take you more than twenty minutes.</dd>
+
+<dt>"Ruby from Other Languages":/en/documentation/ruby-from-other-languages/</dt>
+<dd>Coming to Ruby from another language? Whether it's C, C++, Java, Perl, PHP, or Python, this article has you covered!</dd>
+
+<dt>"Learning Ruby":http://rubylearning.com/</dt>
+<dd>A thorough collection of Ruby study notes for those who are new to the language and in search of a solid introduction to Ruby's concepts and constructs.</dd>
+
+<dt>"Ruby Essentials":http://www.techotopia.com/index.php/Ruby_Essentials</dt>
+<dd>Ruby Essentials is a free on-line book designed to provide a concise and easy to follow guide to learning Ruby.</dd>
+
+<dt>"Ruby &amp; Ruby on Rails programming tutorials":http://www.meshplex.org/wiki/Ruby/Ruby_on_Rails_programming_tutorials</dt>
+<dd>A site that aims to provide well-organized, rich content tutorials for both Ruby and Rails.</dd>
+</dl>
+
+
+h3. Manuals
+
+<dl>
+<dt>"Programming Ruby":http://www.ruby-doc.org/docs/ProgrammingRuby/</dt>
+<dd>The seminal work on Ruby in English, this first edition of the "Pragmatic Programmers' book":http://pragmaticprogrammer.com/titles/ruby/index.html is available for free online.</dd>
+
+<dt>"Ruby User's Guide":http://www.rubyist.net/~slagell/ruby/</dt>
+<dd>Translated from the original Japanese version written by Yukihiro Matsumoto (the creator of Ruby), this version, by Goto Kentaro and Mark Slagell is nice overview of many aspects of the Ruby language.</dd>
+
+<dt>"The Ruby Programming Wikibook":http://en.wikibooks.org/wiki/Ruby_programming_language</dt>
+<dd>A free online manual with beginner and intermediate content plus a thorough language reference.</dd>
+</dl>
+
+h3. Reference Documentation
+
+<dl>
+<dt>"Ruby Core Reference":http://www.ruby-doc.org/core</dt>
+<dd>Pulled straight from the source code using "RDoc":http://rdoc.sourceforge.net, this reference work documents all of the core classes and modules (like String, Array, Symbol, etc...).</dd>
+
+<dt>"Ruby Standard Library Reference":http://www.ruby-doc.org/stdlib</dt>
+<dd>Also pulled from the source code using RDoc, this reference work documents the standard library.</dd>
+
+<dt>"Ruby C API Reference":http://www.ruby-doc.org/doxygen/current/</dt>
+<dd>Documentation for Ruby's underlying C code. Great if you want to write C extensions or contribute to Ruby's development.</dd>
+
+<dt>"YARD Live Documentation Server":http://yardoc.org/docs</dt>
+<dd>Documentation for your favourite Ruby libraries.</dd>
+
+<dt>"rdoc.info":http://rdoc.info/</dt>
+<dd>Your source for open source Ruby documentation.</dd>
+
+<dt>"Rails Searchable API Doc":http://railsapi.com/</dt>
+<dd>Rails and Ruby documentation with smart searching.</dd>
+
+<dt>"RubyDox":http://www.rubydox.net/</dt>
+<dd>Ruby, Rails, Gem and Plugin Documentation.</dd>
+</dl>
+
+h3. Further Reading
+
+"Ruby-Doc.org":http://ruby-doc.org maintains a comprehensive list of English documentation sources. There are also plenty of "books about Ruby":http://www.ruby-doc.org/bookstore. If you have questions about Ruby the "mailing list":/en/community/mailing-lists/ is a great place to start.
86 download.textile
@@ -0,0 +1,86 @@
+Here you can get the latest Ruby distributions in your favorite flavor. The current stable version is 1.9.1. Please be sure to read "Ruby's License":http://www.ruby-lang.org/en/about/license.txt.
+
+h3. Ruby Source Code
+
+Installing from the source code is a great solution for when you are comfortable enough with your platform and perhaps need specific settings for your environment. It's also a good solution in the event that there are no other premade packages for your platform.
+
+* "Ruby 1.9.1-p378":ftp://ftp.ruby-lang.org:21//pub/ruby/1.9/ruby-1.9.1-p378.tar.gz (md5:&nbsp; 9fc5941bda150ac0a33b299e1e53654c) Stable Version (_recommended_)
+* "Stable Snapshot":ftp://ftp.ruby-lang.org:21//pub/ruby/ruby-1.9-stable.tar.gz This is tar'ed and gzip'ed file of the latest stable SVN. It should be better than the last stable release.
+* "Nightly Snapshot":ftp://ftp.ruby-lang.org/pub/ruby/snapshot.tar.gz This is tar'ed and gzip'ed file of the latest SVN. It may contain unfixed problems.
+
+For information about the Ruby Subversion repository, see our "Ruby Core":/en/community/ruby-core/ page.
+
+h3. Ruby on Windows
+
+The Windows platform has several options to install Ruby. The first option is to use the "RubyInstaller":http://rubyinstaller.org/, an installer that contains compiled binaries. The second option is usage of packaged executables and binaries. If you're unsure about how to install Ruby, the first option might be the best for you.
+
+* "Ruby 1.8.6-p398 RubyInstaller":http://rubyforge.org/frs/download.php/71066/rubyinstaller-1.8.6-p398.exe
+(md5:&nbsp;233d6b3ddc4c61436b075b51254cd138) Stable version (_recommended_)
+* "Ruby 1.8.7-p249 RubyInstaller":http://rubyforge.org/frs/download.php/71067/rubyinstaller-1.8.7-p249.exe
+(md5:&nbsp;9ffa7dfdd336340a924f5d34b686ab58) Stable version (_recommended_)
+* "Ruby 1.9.1-p378 RubyInstaller":http://rubyforge.org/frs/download.php/71078/rubyinstaller-1.9.1-p378.exe
+(md5:&nbsp;e686ae092d05c534cbc06490a56fb357) Stable version (_recommended_)
+* "Ruby 1.8.7-p249 Binary":ftp://ftp.ruby-lang.org/pub/ruby/binaries/mswin32/ruby-1.8.7-p249-i386-mswin32.zip
+(md5:&nbsp;4fd37b0b4b21a042cae7f5f0a8daad16) Stable version
+* "Ruby 1.9.1-p378 Binary":ftp://ftp.ruby-lang.org:21/pub/ruby/binaries/mswin32/ruby-1.9.1-p378-i386-mswin32.zip
+(md5:&nbsp;7d14a918cc8d243d3e2c409aff41f454) Stable version
+
+Please note that using the above indicated binaries will require manual download and installation of additional components detailed on "this page":http://www.garbagecollect.jp/ruby/mswin32/en/documents/install.html. Please ensure you have followed and performed these steps prior reporting a bug.
+
+The "RubyInstaller":http://rubyinstaller.org/ does not require these additional tasks.
+
+Please also investigate the use of "pik":http://github.com/vertiginous/pik which eases the process of installing and maintaining concurrent versions of both ruby and gems on Windows.
+
+h3. Ruby On Linux
+
+Depending on the distribution you are using, there are several ways to install Ruby. The first option is simply to download the source code above and compile by hand. However, on some platforms, there are package management solutions that make installing Ruby extremely easy.
+
+For example, on Debian or Ubuntu @apt-get@ provides an easy and elegant solution:
+
+<notextile><r:code lang="sh">
+% sudo apt-get install ruby1.9.1-full
+</r:code></notextile>
+
+The above command installs the current stable version of Ruby 1.9.1. If you prefer to install a Ruby 1.8 version, you can use:
+
+<notextile><r:code lang="sh">
+% sudo apt-get install ruby-full
+</r:code></notextile>
+
+For irb and rdoc you will need to enable the universe repository.
+
+Please also investigate the use of @rvm@, the "Ruby Version Manager":http://rvm.beginrescueend.com, which eases the process of installing and maintaining concurrent versions of both ruby and gems.
+
+h3. Ruby On OS X
+
+Ruby 1.8.6 is fully supported in Mac OS X Leopard including Ruby on Rails, Mongrel, Capistrano, and many other popular Ruby gems (packages). For details, see the "Ruby wiki at MacOS Forge":http://trac.macosforge.org/projects/ruby/wiki.
+
+Mac OS X Tiger is packaged with version 1.8.2 of Ruby, but, for those who haven't upgraded to Leopard, there are a number of options for installing the latest version of Ruby. "Locomotive":http://locomotive.raaum.org/ is a nice choice if you are looking for something to get you up and running quickly for Rails development. Using "MacPorts":http://www.macports.org/ or "Fink":http://fink.sourceforge.net/ might be a little nicer for the more technically savvy.
+
+On MacPorts, you can install Ruby with...
+
+<notextile><r:code lang="sh">
+% port install ruby
+</r:code></notextile>
+
+Fink has a graphical interface (using Fink Commander) for installing Ruby.
+
+Also, since OS X is based on Unix, downloading and installing from the source is just as easy and effective as the other solutions.
+
+For a detailed look at installing Ruby (and Rails), Dan Benjamin's excellent articles "for Tiger":http://hivelogic.com/articles/ruby-rails-mongrel-mysql-osx, "for Leopard":http://hivelogic.com/articles/ruby-rails-leopard, and "for Snow Leopard":http://hivelogic.com/articles/compiling-ruby-rubygems-and-rails-on-snow-leopard/ will get you up and running very quickly.
+
+h3. Ruby On Solaris and OpenSolaris
+
+Ruby 1.8.7 is available for Solaris 8 through Solaris 10 on "Sunfreeware":http://www.sunfreeware.com and Ruby 1.8.7 is available at "Blastwave":http://www.blastwave.org. An optimized Ruby on Rails stack for Solaris 10 is available as "Coolstack":http://cooltools.sunsource.net/coolstack from Sun's Cooltools project.
+
+To install Ruby on "OpenSolaris":http://www.opensolaris.org, please use the "Image Packaging System, or IPS":http://opensolaris.org/os/project/pkg/ client. This will install the latest Ruby binaries and Rubygems directly from the OpenSolaris network repository. It's easy:
+
+<notextile><r:code lang="sh">
+% pfexec pkg install SUNWruby18
+</r:code></notextile>
+
+This will install Ruby, Rubygems, common extensions and their supporting libraries. This package also contains DTrace support and performance optimizations. The locations of various artifacts are described in the "Ruby OpenSolaris ARC Case":http://jp.opensolaris.org/os/community/arc/caselog/2007/600/.
+
+The other OpenSolaris distribution, called the "Solaris Express Community Edition or SXCE":http://opensolaris.org/os/downloads comes with Ruby preinstalled. The version, location etc., are the same as with the vanilla OpenSolaris distribution, and are documented in the above mentioned ARC case.
+
+To install SVR4 packages manually, please visit the "RubyOpenSolaris project @ Rubyforge":http://rubyforge.org/projects/rubyopensolaris.
12 generate.rb
@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'RedCloth'
+
+layout_content = File.read("layout.html")
+
+Dir.glob("*.textile").each do |filename|
+ content = File.read(filename)
+ html = RedCloth.new(content).to_html
+ File.open("output/#{filename.gsub('.textile','.html')}", "w") do |f|
+ f << layout_content.gsub("{{ content }}", html)
+ end
+end
11 layout.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+ <title>Ruby 中文官網</title>
+ <link rel="stylesheet" type="text/css" href="oldstyle.css">
+ </head>
+<body>
+ {{ content }}
+</body>
+</html>
77 libraries.textile
@@ -0,0 +1,77 @@
+A myriad of fascinating and useful libraries are out there for Ruby, many released as "a convenient _gem_ file":http://docs.rubygems.org. Other libraries are released as archived (.zip or .tar.gz) directories of source code. Let's take a look at finding libraries and installing them for your own use.
+
+h3. <a id="finding-libraries"></a>Finding Libraries
+
+"*RubyForge*":http://rubyforge.org/ is a popular home for Ruby libraries. One good spot to browse is its "software map":http://rubyforge.org/softwaremap/trove_list.php, which lists libraries by topic. (If you end up creating your own libraries, you can "register":http://rubyforge.org/register/ your project at Rubyforge to get free Subversion access, web space, and mailing lists.)
+
+The "*Ruby Application Archive*":http://raa.ruby-lang.org/ (or RAA) is a directory of all manner of Ruby software, categorized by function. Right now, the "Database":http://raa.ruby-lang.org/cat.rhtml?category_major=Library;category_minor=Database
+category has the most entries, leading by 1 over "Net.":http://raa.ruby-lang.org/cat.rhtml?category_major=Library;category_minor=Net
+"HTML":http://raa.ruby-lang.org/cat.rhtml?category_major=Library;category_minor=HTML and "XML":http://raa.ruby-lang.org/cat.rhtml?category_major=Library;category_minor=XML
+are also popular categories. There are even 4
+"Physics":http://raa.ruby-lang.org/cat.rhtml?category_major=Library;category_minor=Physics entries.
+
+h3. <a id="using-rubygems"></a>Using RubyGems
+
+As stated on the "RubyGems website":http://docs.rubygems.org, "RubyGems is the premier ruby packaging system. It provides a standard format for distributing Ruby programs and libraries, and an easy to use tool for managing the installation of gem packages." In some ways, it is a distribution packaging system similar to, say, apt-get, targeted at ruby software. The official gems repository is "Gemcutter":http://gemcutter.org.
+
+While the Windows installer includes RubyGems, many operating systems do not. Please refer to "Installing RubyGems":#installing-rubygems below, if next gem commands do not work for you.
+
+h4. Searching for Gems
+
+The *search* command can be used to look for gems of a certain name. To search for the word "html" in the name of a gem:
+
+<notextile><r:code lang="bash">
+ $ gem search html --remote
+
+ *** REMOTE GEMS ***
+
+ html-sample (1.0, 1.1)
+ A sample Ruby gem, just to illustrate how RubyGems works.
+</r:code></notextile>
+
+(_The @--remote@ flag indicates that we'll be searching the official Gemcutter gems._)
+
+h4. Installing a Gem
+
+Once you know which gem you'd like to *install*:
+
+<notextile><r:code lang="bash">
+ $ gem install html-sample
+</r:code></notextile>
+
+You can even install just a certain version of the library using the @--version@ flag.
+
+<notextile><r:code lang="bash">
+ $ gem install html-sample --version 1.0
+</r:code></notextile>
+
+h4. Listing All Gems
+
+For a complete *list* of all gems at Gemcutter:
+
+<notextile><r:code lang="bash">
+ $ gem list --remote
+</r:code></notextile>
+
+To list only gems you've installed, leave off the flag.
+
+<notextile><r:code lang="bash">
+ $ gem list
+</r:code></notextile>
+
+For more on using RubyGems, see "*the official manual*":http://rubygems.org/read/chapter/1, which includes examples for using gems in your Ruby scripts.
+
+h3. <a id="installing-rubygems"></a>Installing RubyGems
+
+To install RubyGems, download RubyGems 0.9.0 from its "downloads page":http://rubyforge.org/frs/?group_id=126. Extract the archive and run @setup.rb@. On some operating systems you may need to do this as root.
+
+For example, on Linux:
+
+<notextile><r:code lang="bash">
+$ tar xzvf rubygems-0.9.0.tar.gz
+$ cd rubygems-0.9.0
+$ su -
+# ruby setup.rb
+</r:code></notextile>
+
+If you need some further direction on how to install Ruby, check out the "*installation chapter*":http://rubygems.org/read/chapter/3 in the RubyGems manual.
24 libraries.top-projects.textile
@@ -0,0 +1,24 @@
+<p><em>This is a list of the 30 most downloaded Ruby projects (according to <a href="http://rubyforge.org">RubyForge</a>).</em></p>
+
+<r:top_projects src="http://rubyforge.org/export/top_downloads.php">
+<table id="top-projects-table" border="0" cellspacing="0" cellpadding="0">
+<thead>
+<tr>
+<th class="rank">Rank</th>
+<th class="project">Project</th>
+<th class="downloads">Downloads</th>
+</tr>
+</thead>
+<tbody>
+<r:each limit="30">
+<tr>
+<td class="rank"><r:rank /></td>
+<td class="project"><h4><r:link /></h4><p><r:description /></p></td>
+<td class="downloads"><r:downloads /></td>
+</tr>
+</r:each>
+</tbody>
+</table>
+</r:top_projects>
+
+<p><a href="http://rubyforge.org/top/toplist.php?type=downloads">View the full list of the top 100 downloads at RubyForge&#8230;</a></p>
31 mailing-lists.manual-instructions.textile
@@ -0,0 +1,31 @@
+To subscribe to a mailing list, please send a mail with the following mail body (not the subject) to the automated "controller" address:
+
+<r:code lang="mail">subscribe Your-First-Name Your-Last-Name</r:code>
+
+e.g.
+
+<r:code lang="mail">subscribe John Doe</r:code>
+
+<dl>
+<dt>Ruby-Talk</dt>
+<dd>For the Ruby-Talk list, the controller address is [ruby-talk-ctl@ruby-lang.org](mailto:ruby-talk-ctl@ruby-lang.org), the posting address is [ruby-talk@ruby-lang.org](mailto:ruby-talk@ruby-lang.org), and the human administrator address is [ruby-talk-admin@ruby-lang.org](mailto:ruby-talk-admin@ruby-lang.org).</dd>
+
+<dt>Ruby-Core</dt>
+<dd>For the Ruby-Core list, the controller address is [ruby-core-ctl@ruby-lang.org](mailto:ruby-core-ctl@ruby-lang.org), the posting address is [ruby-core@ruby-lang.org](mailto:ruby-core@ruby-lang.org), and the "human" administrator address is [ruby-core-admin@ruby-lang.org](mailto:ruby-core-admin@ruby-lang.org).</dd>
+
+<dt>Ruby-Doc</dt>
+<dd>For the Ruby-Doc list, the controller address is [ruby-doc-ctl@ruby-lang.org](mailto:ruby-doc-ctl@ruby-lang.org), the posting address is [ruby-doc@ruby-lang.org](mailto:ruby-doc@ruby-lang.org), and the "human" administrator address is [ruby-doc-admin@ruby-lang.org](mailto:ruby-doc-admin@ruby-lang.org).</dd>
+
+<dt>Ruby-CVS</dt>
+<dd>For the Ruby-CVS list, the controller address is [ruby-cvs-ctl@ruby-lang.org](mailto:ruby-cvs-ctl@ruby-lang.org), the posting address is [ruby-cvs@ruby-lang.org](mailto:ruby-cvs@ruby-lang.org), and the "human" administrator address is [ruby-cvs-admin@ruby-lang.org](mailto:ruby-cvs-admin@ruby-lang.org).</dd>
+</dd>
+
+
+h3. Unsubscribing
+
+To unsubscribe from a list, send a mail which body is "unsubscribe" to the controller address.
+
+
+h3. Getting Help
+
+To see the list of commands, send a mail which body is "help" to the controller address.
42 mailing-lists.textile
@@ -0,0 +1,42 @@
+<r:subscribe>
+<r:unless_success>
+Mailing-lists are a great way to keep your finger on the pulse of the Ruby community. Ruby has four primary English speaking mailing lists:
+
+<dl>
+<dt>Ruby-Talk</dt>
+<dd>This is the most popular mailing-list and deals with general topics about Ruby. Ruby-Talk is mirrored by the <a href="news:comp.lang.ruby">comp.lang.ruby</a> newsgroup and <a href="http://ruby-forum.com">Ruby-Forum.com</a>. (<a href="http://www.rubyweeklynews.org/">Weekly Summaries</a>, <a href="http://rubyhacker.com/clrFAQ.html">FAQ</a>, <a href="http://blade.nagaokaut.ac.jp/ruby/ruby-talk/index.shtml">Archives</a>)</dd>
+
+<dt>Ruby-Core</dt>
+<dd>This list deals with core and implementation topics about Ruby, often used to run patches for review. (<a href="http://blade.nagaokaut.ac.jp/ruby/ruby-core/index.shtml">Archives</a>)</dd>
+
+<dt>Ruby-Doc</dt>
+<dd>This list is for discussing documentation standards and tools for Ruby. (<a href="http://dir.gmane.org/gmane.comp.lang.ruby.documentation">Archives at Gmane</a>)</dd>
+
+<dt>Ruby-CVS</dt>
+<dd>This list reports all commits to Ruby&#8217;s CVS repository.</dd>
+</dl>
+
+<r:form id="subscriptions-form">
+ <h2>Subscribe or Unsubscribe</h2>
+ <r:if_error><p class="error"><r:error_message /></p></r:if_error>
+ <table class="fieldset" cellspacing="0" cellpadding="0" border="0">
+ <tr> <td class="label">Mailing List </td> <td><r:list_select /> </td> </tr>
+ <tr> <td class="label">First Name </td> <td><r:first_name_input /></td> </tr>
+ <tr> <td class="label">Last Name </td> <td><r:last_name_input /> </td> </tr>
+ <tr> <td class="label">E-mail Address</td> <td><r:email_input /> </td> </tr>
+ <tr> <td class="label">Action </td> <td><r:action_select /> </td> </tr>
+ </table>
+ <div class="buttons"><input class="button" type="submit" value="Submit Form" /></div>
+</r:form>
+</r:unless_success>
+
+<r:if_success>
+<h2>Confirmation E-mail</h2>
+<p>You should receive a confirmation message within a few minutes.
+ Once you have received the message, follow the instructions it
+ contains to complete the process.</p>
+<p><r:link>Subscribe to another mailing list&#8230;</r:link></p>
+</r:if_success>
+</r:subscribe>
+<br />
+<p>If you fail to receive a confirmation e-mail using the form, try subscribing the <a href="manual-instructions/">manual way</a>.</p>
0 output/.gitignore
No changes.
843 output/oldstyle.css
@@ -0,0 +1,843 @@
+
+
+
+
+
+/* The W3C Core Styles Copyright (c) 1998 W3C (mit, inria, Keio), All Rights
+Reserved. W3C liability, trademark, document use and software licensing rules
+apply. See http://www.w3.org/Consortium/Legal/ipr-notice.html
+
+This stylesheet has been served in a form to avoid known bugs in your user
+agent's css implementation. Copying and serving this stylesheet to other
+agents may lead to unexpected results. Please refer to its address rather than
+copy it. */
+
+
+
+
+
+ /* begin body type */ /* 1 - humanist sans a */
+
+body {
+ font-size: 1em;
+ font-weight: normal;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ font-family: Verdana, Myriad Web, Syntax, sans-serif;
+ font-size-adjust: .58;
+ }
+
+p, blockquote, ul, ol, dl, dd, li, dir, menu {
+ /* inherit from body */
+ }
+
+small {
+ font-size: .92em;
+ }
+
+big {
+ font-size: 1.17em;
+ }
+
+pre {
+ font-family: 'Monotype.com', Courier New, monospace;
+ }
+
+ol li {
+ list-style-type: decimal;
+ }
+
+ol ol li {
+ list-style-type: lower-alpha;
+ }
+
+ol ol ol li {
+ list-style-type: lower-roman;
+ }
+
+table, tbody, tr, td {
+ font-size: 1em;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ font-family: Verdana, Myriad Web, Syntax, sans-serif;
+ font-size-adjust: .58;
+ }
+
+ /* end body type */
+
+
+
+
+ /* begin header type */ /* 2 - serif a */
+
+h1 {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 2.0em;
+ font-weight: 600;
+ font-style: normal;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ }
+
+h2 {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 1.75em;
+ font-weight: 500;
+ font-style: normal;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ }
+
+h3 {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 1.58em;
+ font-weight: 600;
+ font-style: italic;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ }
+
+h4 {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 1.33em;
+ font-weight: 600;
+ font-style: normal;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ }
+
+h5, dt {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 1.17em;
+ font-weight: 600;
+ font-style: italic;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ }
+
+h6 {
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ font-size: 1em;
+ font-weight: 700;
+ font-style: normal;
+ text-decoration: none;
+ word-spacing: normal;
+ letter-spacing: .1em;
+ font-variant: small-caps
+ }
+
+tfoot, thead {
+ font-size: 1em;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ }
+
+th {
+ vertical-align: baseline;
+ font-size: 1em;
+ font-weight: bold;
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif;
+ font-size-adjust: .4;
+ }
+
+hr {
+ visibility: visible;
+ }
+
+ /* end header type */
+
+
+
+
+ /* begin affordances */ /* 7 - rubric */
+
+a, address, blockquote, body, cite, code, dd, del, dfn,
+div, dl, dt, em, form, h1, h2, h3, h4, h5, h6, iframe, img, kbd,
+li, object, ol, p, q, samp, small, span, strong, sub, sup, ul, var,
+applet, big, center, dir, font, hr, menu, pre,
+abbr, acronym, bdo, button, fieldset, ins, label {
+ word-spacing: normal;
+ letter-spacing: normal;
+ text-transform: none;
+ text-decoration: none;
+ border-color: #999;
+ border-style: none;
+ }
+
+body {
+ color: black;
+ background: #fffff5;
+ }
+
+em {
+ font-style: normal;
+ font-weight: bold;
+ color: black;
+ background: #fffff5;
+ }
+
+strong {
+ font-style: italic;
+ background: #fffff5;
+ font-weight: bold;
+ color: black;
+ }
+
+em strong, strong em {
+ text-transform: uppercase;
+ font-style: normal;
+ font-weight: bolder;
+ background: #fffff5;
+ color: black;
+ }
+
+b {
+ font-weight: bold;
+ }
+
+i {
+ font-style: italic;
+ }
+
+.warning {
+ text-transform: none;
+ font-style: normal;
+ font-weight: bolder;
+ background: #FF0;
+ color: red;
+ }
+
+del {
+ text-decoration: line-through;
+ background: #fc6;
+ }
+
+ins {
+ text-decoration: none;
+ background: #9F3;
+ }
+
+var, cite, dfn, .note {
+ font-style: italic;
+ }
+
+address {
+ font-style: normal;
+ letter-spacing: .1em;
+ }
+
+acronym {
+ font-variant: small-caps;
+ letter-spacing: 0.1em;
+ }
+
+h1, h2, h3, h4, h5, h6, dt, th, thead, tfoot {
+ color: #C00;
+ background: #fffff5;
+ }
+
+hr {
+ color: black;
+ }
+
+#colophon {
+ display: none;
+ }
+
+col, colgroup, table, tbody, td, tr {
+ color: black;
+ text-decoration: none;
+ border-color: black;
+ border-style: none;
+ background: #fffff5;
+ }
+
+a:link {
+ text-decoration: none;
+ font-weight: bold;
+ color: #33F;
+ background: #fffff5;
+ }
+
+a:visited {
+ text-decoration: none;
+ font-weight: bold;
+ color: #93C;
+ background: #fffff5;
+ }
+
+a:active {
+ text-decoration: none;
+ font-weight: bold;
+ color: black;
+ background: #ccf;
+ }
+
+a:hover {
+ text-decoration: none;
+ color: #fffff5;
+ background: #33F;
+ }
+
+a.offsite {
+ text-decoration: none;
+ font-weight: normal;
+ color: #33F;
+ background: #fffff5;
+ }
+
+ /* end affordances */
+
+
+
+
+ /* begin vertical */ /* 1 - pentatonic a */
+
+a, address, blockquote, cite, code, dd, del, dfn,
+div, dl, dt, em, form, h1, h2, h3, h4, h5, h6, iframe, img, kbd,
+li, object, ol, p, q, samp, small, span, strong, sub, sup, ul, var,
+applet, b, big, center, dir, font, hr, i, menu, pre, s, strike, tt,
+u, abbr, acronym, bdo, button, fieldset, ins, label {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ vertical-align: baseline;
+ }
+
+body {
+ line-height: 1.58em;
+ }
+
+div > p:first-child, body > p:first-child, td > p:first-child {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h1 + p, h2 + p, h3 + p, h4 + p, h5 + p, h6 + p, div + p, p.initial {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h1, h2, h3, h4, h5, h6 {
+ line-height: 1.33em;
+ }
+
+h1 {
+ margin-top: 1.33em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h2 {
+ margin-top: 1.75em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h3 {
+ margin-top: 1.58em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h4 {
+ margin-top: 1.33em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h5 {
+ margin-top: 1.17em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+h6 {
+ margin-top: 1em;
+ margin-bottom: .33em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+p {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+blockquote, fieldset, form, ul, ol, dl, dir, menu {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+dt {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+dd {
+ margin-top: 0;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+ul ul, ol ol, li address, li dl, li ol, li p, li ul, li dir, li hr, li menu, li pre, li h1, li h2, li h3, li h4, li h5, li h6, dd address, dd dl, dd ol, dd p, dd ul, dd dir, dd hr, dd menu, dd pre, dd h1, dd h2, dd h3, dd h4, dd h5, dd h6 {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+li {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+address {
+ margin-top: 1.58em;
+ margin-bottom: 1.58em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+pre {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ line-height: 1.25em;
+ }
+
+hr {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ height: 1px;
+ }
+
+div, center {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+.subhead {
+ margin-top: .75em;
+ margin-bottom: .75em;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+.stb {
+ margin-top: 2.17em;
+ margin-bottom: .75em;
+ padding-top: 2.17em;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ border-style: solid
+ }
+
+.mtb {
+ margin-top: 3.08em;
+ margin-bottom: .75em;
+ padding-top: 3.08em;
+ padding-bottom: 0;
+ border-top: .1em;
+ border-bottom: 0;
+ border-style: solid
+ }
+
+.ltb {
+ margin-top: 4.34em;
+ margin-bottom: .75em;
+ padding-top: 4.34em;
+ padding-bottom: 0;
+ border-top: .25em;
+ border-bottom: 0;
+ border-style: solid
+ }
+
+col, colgroup, table, tbody, td, tfoot, th, thead, tr {
+ margin-top: 0;
+ margin-bottom: 0;
+ padding-top: 0;
+ padding-bottom: 0;
+ border-top: 0;
+ border-bottom: 0;
+ }
+
+td, th {
+ line-height: 1.33em;
+ }
+
+ /* end vertical */
+
+
+
+
+ /* begin horizontal */ /* 1 - compact */
+
+a, address, blockquote, cite, code, dd, del, dfn,
+div, dl, dt, em, form, h1, h2, h3, h4, h5, h6, iframe, img, kbd,
+li, object, ol, p, q, samp, small, span, strong, sub, sup, ul, var,
+applet, b, big, center, dir, font, hr, i, menu, pre, s, strike, tt,
+u, abbr, acronym, bdo, button, fieldset, ins, label {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ float: none;
+ clear: none;
+ list-style-position: outside;
+ }
+
+address, blockquote, dl, fieldset, form, ol,
+p, ul, dir, hr, menu, pre {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ }
+
+div > p:first-child, body > p:first-child, td > p:first-child {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ text-indent: 0;
+ }
+
+h1 + p, h2 + p, h3 + p, h4 + p, h5 + p, h6 + p, div + p, p.initial {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ text-indent: 0;
+ }
+
+h1 {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ }
+
+h2 {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ }
+
+h3 {
+ margin-left: 0;
+ margin-right: 0;
+ padding-left: 0;
+ padding-right: 0;
+ border-left: 0;
+ border-right: 0;
+ text-align: left;
+ }
+
+h4 {
+ margin-left: 0;
+ margin-right: 0;
+