hash = { "key1" => "val1", "key2" => "val2" }

	string = ""

	hash.each { |k,v| string << "#{k} is #{v}\n" }

	puts string

	# key1 is val1

	# key2 is val2

	string = ""

	hash.each { |k,v| string << k << " is " << v << "\n" }

	puts hash.keys.join("\n") + "\n"

	# key1

	# key2

	number = 5

	"The number is #{number}."                      # => "The number is 5."

	"The number is #{5}."                           # => "The number is 5."

	"The number after #{number} is #{number.next}."

	# => "The number after 5 is 6."

	"The number prior to #{number} is #{number-1}."

	# => "The number prior to 5 is 4."

	"We're ##{number}!"                             # => "We're #5!"

	"#{number}" == '5'                             # => true

	%{Here is #{class InstantClass

	   def bar

	      "some text"

	    end

	 end

	 InstantClass.new.bar

	}.}

	# => "Here is some text."

	template = 'Oceania has always been at war with %s.'

	template % 'Eurasia'  # => "Oceania has always been at war with Eurasia."

	template % 'Eastasia' # => "Oceania has always been at war with Eastasia."



	'To 2 decimal places: %.2f' % Math::PI       # => "To 2 decimal places: 3.14"

	'Zero-padded: %.5d' % Math::PI               # => "Zero-padded: 00003"

	require 'erb'



	template = ERB.new %q{Chunky <%= food %>!}

	food = "bacon"

	template.result(binding)                     # => "Chunky bacon!"

	food = "peanut butter"

	template.result(binding)                     # => "Chunky peanut butter!"

	puts template.result

	# Chunky peanut butter!

	template = %q{

	<% if problems.empty? %>

	  Looks like your code is clean!

	<% else %>

	  I found the following possible problems with your code:

	  <% problems.each do |problem, line| %>

	    * <%= problem %> on line <%= line %>

	  <% end %>

	<% end %>}.gsub(/^\s+/, '')

	template = ERB.new(template, nil, '<>')



	problems = [["Use of is_a? instead of duck typing", 23],

	            ["eval() is usually dangerous", 44]]

	template.run(binding)

	# I found the following possible problems with your code:

	# * Use of is_a? instead of duck typing on line 23

	# * eval() is usually dangerous on line 44



	problems = []

	template.run(binding)

	# Looks like your code is clean!

	s = ".sdrawkcab si gnirts sihT"

	s.reverse                            # => "This string is backwards."

	s                                    # => ".sdrawkcab si gnirts sihT"



	s. 

reverse!                           # => "This string is backwards."

	s                                    # => "This string is backwards."

	s = "order. wrong the in are words These"

	s.split(/(\s+)/). 

reverse!.join('')   # => "These words are in the wrong order."

	s.split(/\b/).reverse!.join('')      # => "These words are in the wrong. order"

	"Three little words".split(/\s+/)   # => ["Three", "little", "words"]

	"Three little words".split(/(\s+)/)

	# => ["Three", " ", "little", " ", "words"]

	octal = "\000\001\010\020"

	octal.each_byte { |x| puts x }

	# 0

	# 1

	# 8

	# 16



	hexadecimal = "\x00\x01\x10\x20"

	hexadecimal.each_byte { |x| puts x }

	# 0

	# 1

	# 16

	# 32

	open('smiley.html', 'wb') do |f|

	  f << '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">'

	  f << "\xe2\x98\xBA"

	end

	"\a" == "\x07" # => true # ASCII 0x07 = BEL (Sound system bell)

	"\b" == "\x08" # => true # ASCII 0x08 = BS (Backspace)

	"\e" == "\x1b" # => true # ASCII 0x1B = ESC (Escape)

	"\f" == "\x0c" # => true # ASCII 0x0C = FF (Form feed)

	"\n" == "\x0a" # => true # ASCII 0x0A = LF (Newline/line feed)

	"\r" == "\x0d" # => true # ASCII 0x0D = CR (Carriage return)

	"\t" == "\x09" # => true # ASCII 0x09 = HT (Tab/horizontal tab)

	"\v" == "\x0b" # => true # ASCII 0x0B = VT (Vertical tab)

	?a                 # => 97

	?!                 # => 33

	?\n                # => 10

	'a'[0]             # => 97

	'bad sound'[1]     # => 97

	97.chr              # => "a"

	33.chr              # => "!"

	10.chr              # => "\n"

	0.chr               # => "\000"

	256.chr             # RangeError: 256 out of char range

	:a_ 

symbol.to_s                        # => "a_symbol"

	:AnotherSymbol.id2name                # => "AnotherSymbol"

	:"Yet another symbol!".to_s           # => "Yet another symbol!"

	:dodecahedron.object_id               # => 4565262

	symbol_name = "dodecahedron"

	symbol_name.intern                    # => :dodecahedron

	symbol_name.intern.object_id          # => 4565262

	"string".object_id          # => 1503030

	"string".object_id          # => 1500330

	:symbol.object_id           # => 4569358

	:symbol.object_id           # => 4569358

	"string1" == "string2"       # => false

	:symbol1 == :symbol2         # => false

	'foobar'.each_byte { |x| puts "#{x} = #{x.chr}" }

	# 102 = f

	# 111 = o

	# 111 = o

	# 98 = b

	# 97 = a

	# 114 = r

	'foobar'.scan( /./ ) { |c| puts c }

	# f

	# o

	# o

	# b

	# a

	# r

	"foo\nbar".each { |x| puts x }

	# foo

	# bar

	french = "\xc3\xa7a va"

	french.scan(/./) { |c| puts c }

	#

	#

	# a

	#

	# v

	# a



	french.scan(/./u) { |c| puts c }

	# ç

	# a

	#

	# v

	# a



	$KCODE = 'u'

	french.scan(/./) { |c| puts c }

	# ç

	# a

	#

	# v

	# a

	class String

	  def 

word_count

	    frequencies = Hash.new(0)

	    downcase.scan(/\w+/) { |word| frequencies[word] += 1 }

	   return frequencies

	  end

	end



	%{Dogs dogs dog dog dogs.}.word_count

	# => {"dogs"=>3, "dog"=>2}

	%{"I have no shame," I said.}.word_count

	# => {"no"=>1, "shame"=>1, "have"=>1, "said"=>1, "i"=>2}

	# Just like /\w+/, but doesn't consider underscore part of a word.

	/[0-9A-Za-z]/



	# Anything that's not whitespace is a word.

	/[^\S]+/



	# Accept dashes and apostrophes as parts of words.

	/[-'\w]+/



	# A pretty good heuristic for matching English words.

	/(\w+([-'.]\w+)*/

	s = 'HELLO, I am not here. I WENT to tHe MaRKEt.'

	s. 

upcase           # => "HELLO, I AM NOT HERE. I WENT TO THE MARKET."

	s. 

downcase         # => "hello, i am not here. i went to the market."

	s.swapcase         # => "hello, i AM NOT HERE. i went TO ThE mArkeT."

	s.capitalize       # => "Hello, i am not here. i went to the market."

	un_banged = 'Hello world.'

	un_banged.upcase     # => "HELLO WORLD."

	un_banged            # => "Hello world."



	banged = 'Hello world.'

	banged.upcase!       # => "HELLO WORLD."

	banged               # => "HELLO WORLD."

	class String

	  def capitalize_first_letter

	    self[0].chr.capitalize + self[1, size]

	  end



	  def capitalize_first_letter!

	    unless self[0] == (c = self[0,1].upcase[0])

	      self[0] = c

	      self

	    end

	    # Return nil if no change was made, like upcase! et al.

	  end

	end



	s = 'i told Alice. She remembers now.'

	s.capitalize_first_letter        # => "I told Alice. She remembers now."

	s                                # => "i told Alice. She remembers now."

	s.capitalize_first_letter!

	s                                # => "I told Alice. She remembers now."

	" \tWhitespace at beginning and end. \t\n\n". 

strip

	s = "Some text."

	s. 

center(15)

	s. 

ljust(15)

	s. 

rjust(15)

	#Normalize Ruby source code by replacing tabs with spaces

	rubyCode.gsub("\t", "     ")



	#Transform Windows-style newlines to Unix-style newlines

	"Line one\n\rLine two\n\r".gsub(\n\r", "\n")

	# => "Line one\nLine two\n"



	#Transform all runs of whitespace into a single space character

	"\n\rThis string\t\t\tuses\n all\tsorts\nof whitespace.".gsub(/\s+/," ")

	# => " This string uses all sorts of whitespace."

	" \bIt's whitespace, Jim,\vbut not as we know it.\n".gsub(/[\s\b\v]+/, " ")

	# => "It's whitespace, Jim, but not as we know it."

	s = "   Whitespace madness! "

	s.lstrip                        # => "Whitespace madness! "

	s.rstrip                        # => "   Whitespace madness!"

	'A string'.respond_to? :to_str        # => true

	Exception.new.respond_to? :to_str     # => true

	4.respond_to? :to_str                 # => false

	def join_to_successor(s)

	  raise ArgumentError, 'No successor method!' unless s.respond_to? :succ

	  return "#{s}#{s.succ}"

	end



	join_to_successor('a')           # => "ab"	

	join_to_successor(4)             # => "45"

	join_to_successor(4.01)

	# ArgumentError: No successor method!

	s = 'My kingdom for a string!'

	s. 

slice(3,7)                      # => "kingdom"

	s[3,7]                            # => "kingdom"

	s[0,3]                            # => "My "

	s[11, 5]                          # => "for a"

	s[11, 17]                         # => "for a string!"

	s[/.ing/]                         # => "king"

	s[/str.*/]                        # => "string!"

	s.slice(3)                        # => 107

	s[3]                              # => 107

	107.chr                           # => "k"

	s.slice(3,1)                      # => "k"

	s[3,1]                            # => "k"

	s.slice(-7,3)                     # => "str"

	s[-7,6]                           # => "string"

	s[15…s.length]                  # => "a string!"

	$KCODE='u'

	require 'jcode'

	$ ruby -Ku -rjcode

	#!/usr/bin/ruby -Ku -rjcode

	string = "\xef\xbc\xa1" + "\xef\xbc\xa2" + "\xef\xbc\xa3" +

	         "\xef\xbc\xa4" + "\xef\xbc\xa5" + "\xef\xbc\xa6"

	string.size                                          # => 18

	string.jsize                                         # => 6

	string.count "\xef\xbc\xa2"                          # => 13

	string.jcount "\xef\xbc\xa2"                         # => 1

	"\xef\xbc\xa2".length                                # => 3

	"\xef\xbc\xa2".jlength                               # => 1

	def wrap(s, width=78)

	  s.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")

	end



	wrap("This text is too short to be wrapped.")

	# => "This text is too short to be wrapped.\n"



	puts wrap("This text is not too short to be wrapped.", 20)

	# This text is not too

	# short to be wrapped.



	puts wrap("These ten-character columns are stifling my creativity!", 10)

	# These

	# ten-character

	# columns

	# are

	# stifling

	# my

	# creativity!

	poetry = %q{It is an ancient Mariner,

	And he stoppeth one of three.

	"By thy long beard and glittering eye,

	Now wherefore stopp'st thou me?}



	puts wrap(poetry, 20)

	# It is an ancient

	# Mariner,

	# And he stoppeth one

	# of three.

	# "By thy long beard

	# and glittering eye,

	# Now wherefore

	# stopp'st thou me?

	prose = %q{I find myself alone these days, more often than not,

	watching the rain run down nearby windows. How long has it been

	raining? The newspapers now print the total, but no one reads them

	anymore.}



	puts wrap(prose, 60)

	# I find myself alone these days, more often than not,

	# watching the rain run down nearby windows. How long has it

	# been

	# raining? The newspapers now print the total, but no one

	# reads them

	# anymore.

	def reformat_wrapped(s, width=78)

	 s.gsub(/\s+/, " ").gsub(/(.{1,#{width}})( |\Z)/, "\\1\n")

	end

	('aa'..'ag').each { |x| puts x }

	# aa

	# ab

	# ac

	# ad

	# ae

	# af

	# ag

	def endless_string_succession(start)

	  while true

	    yield start

	    start = start.succ

	  end

	end

	endless_string_succession('fol') do |x|

	  puts x

	  break if x[-1] == x[-2]

	end

	# fol

	# fom

	# fon

	# foo

	'89999'.succ                   # => "90000"

	'nzzzz'.succ                   # => "oaaaa"

	'Zzz'.succ                     # => "AAaa"

	'z'.succ                       # => "aa"

	'aa'.succ                      # =>  "ab"

	'zz'.succ                      # => "aaa"

	string = 'This is a 30-character string.'



	if string =~ /([0-9]+)-character/ and $1.to_i == string.length

	  "Yes, there are #$1 characters in that string."

	end

	# => "Yes, there are 30 characters in that string."

	match = Regexp.compile('([0-9]+)-character').match(string)

	if match && match[1].to_i == string.length

	  "Yes, there are #{match[1]} characters in that string."

	end

	# => "Yes, there are 30 characters in that string."

	string = "123"



	case string

	when /^[a-zA-Z]+$/

	  "Letters"

	when /^[0-9]+$/

	  "Numbers"

	else

	  "Mixed"

	end

	# => "Numbers"

	/something/

	Regexp.new("something")

	Regexp.compile("something")

	%r{something}

	class String

	  def mgsub(key_value_pairs=[].freeze)

	    regexp_fragments = key_value_pairs.collect { |k,v| k }

	    gsub( 

Regexp.union(*regexp_fragments)) do |match|

	      key_value_pairs.detect{|k,v| k =~ match}[1]

	    end

	  end

	end

	"GO HOME!".mgsub([[/.*GO/i, 'Home'], [/home/i, 'is where the heart is']])

	# => "Home is where the heart is!"

	"Here is number #123".mgsub([[/[a-z]/i, '#'], [/#/, 'P']])

	# => "#### ## ###### P123"

	"GO HOME!".gsub(/.*GO/i, 'Home').gsub(/home/i, 'is where the heart is')

	# => "is where the heart is is where the heart is!"



	"Here is number #123".gsub(/[a-z]/i, "#").gsub(/#/, "P")

	# => "PPPP PP PPPPPP P123"

	"between".mgsub(/ee/ => 'AA', /e/ => 'E') # Bad code

	# => "bEtwEEn"



	"between".mgsub([[/ee/, 'AA'], [/e/, 'E']]) # Good code

	# => "bEtwAAn"

	test_addresses = [ #The following are valid addresses according to RFC822.

	                   'joe@example.com', 'joe.bloggs@mail.example.com',

	                   'joe+ruby-mail@example.com', 'joe(and-mary)@example.museum',

	                   'joe@localhost',

	                   # Complete the list with some invalid addresses

	                   'joe', 'joe@', '@example.com',

	                   'joe@example@example.com',

	                   'joe and mary@example.com' ]

	valid = '[^ @]+' # Exclude characters always invalid in email addresses

	username_and_machine = /^#{valid}@#{valid}$/



	test_addresses.collect { |i| i =~ username_and_machine }

	# => [0, 0, 0, 0, 0, nil, nil, nil, nil, nil]

	username_and_machine_with_tld = /^#{valid}@#{valid}\.#{valid}$/



	test_addresses.collect { |i| i =~ username_and_machine_with_tld }

	# => [0, 0, 0, 0, nil, nil, nil, nil, nil, nil]

	require 'rubygems'

	require 'classifier'



	classifier = Classifier::Bayes.new('Spam', 'Not spam')



	classifier.train_spam 'are you in the market for viagra? we sell viagra'

	classifier.train_not_spam 'hi there, are we still on for lunch?'

	classifier.classify "we sell the cheapest viagra on the market"

	# => "Spam"

	classifier.classify "lunch sounds great"

	# => "Not spam"

	classifier

	# => #<Classifier::Bayes:0xb7cec7c8

	#       @categories={:"Not spam"=>

	#                      { :lunch=>1, :for=>1, :there=>1,

	#                        :"?"=>1, :still=>1, :","=>1 },

	#                    :Spam=>

	#                      { :market=>1, :for=>1, :viagra=>2, :"?"=>1, :sell=>1 }

	#                   },

	#       @total_words=12>

	'400'.to_i                           # => 400

	'3.14'.to_f                          # => 3.14

	'1.602e-19'.to_f                     # => 1.602e-19

	'405'.oct                            # => 261

	'405'.to_i(8)                        # => 261

	'405'.hex                            # => 1029

	'405'.to_i(16)                       # => 1029

	'fed'.hex                            # => 4077

	'fed'.to_i(16)                       # => 4077

	"13: a baker's dozen".to_i                         # => 13

	'1001 Nights'.to_i                                 # => 1001

	'The 1000 Nights and a Night'.to_i                 # => 0

	'60.50 Misc. Agricultural Equipment'.to_f          # => 60.5

	'$60.50'.to_f                                      # => 0.0

	'Feed the monster!'.hex                            # => 65261

	'I fed the monster at Canoga Park Waterslides'.hex # => 0

	'0xA2Z'.hex                                        # => 162

	'-10'.oct                                          # => -8

	'-109'.oct                                         # => -8

	'3.14'.to_i                                        # => 3

	1.8 + 0.1                            # => 1.9

	1.8 + 0.1 == 1.9                     # => false

	1.8 + 0.1 > 1.9                      # => true

	require 'bigdecimal'



	BigDecimal("10").to_s                # => "0.1E2"

	BigDecimal("1000").to_s              # => "0.1E4"

	BigDecimal("1000").to_s("F")         # => "1000.0"



	BigDecimal("0.123456789").to_s       # => "0.123456789E0"

	nm = "0.123456789012345678901234567890123456789"

	nm.to_f                         # => 0.123456789012346

	BigDecimal(nm).to_s

	# => "0.123456789012345678901234567890123456789E0"

	BigDecimal("105000").split

	# => [1, "105", 10, 6]

	# That is, 0.105*(10**6)



	BigDecimal("-0.005").split

	# => [-1, "5", 10, -2]

	# That is, -1 * (0.5*(10**-2))

	(BigDecimal("2") / BigDecimal("3")).to_s

	# => "0.6666666666666667E0"



	2.0/3

	# => 0.666666666666667

	float = 2.0/3.0                      # => 0.666666666666667

	float * 100                          # => 66.6666666666667

	float * 100 / 42                     # => 1.58730158730159



	require 'rational'

	rational = Rational(2, 3)            # => Rational(2, 3)

	rational.to_f                        # => 0.666666666666667

	rational * 100                       # => Rational(200, 3)

	rational * 100 / 42                  # => Rational(100, 63)

	10 + Rational(2,3)                   # => Rational(32, 3)

	require 'bigdecimal'

	BigDecimal('10') + Rational(2,3)     # => 10.6666666666667

	Math::sqrt(Rational(2,3))            # => 0.816496580927726

	Math::sqrt(Rational(25,1))           # => 5.0 

	Math::log10(Rational(100, 1))        # => 2.0

	rand                                 # => 0.517297883846589

	rand                                 # => 0.946962603814814

	rand(5)                              # => 0

	rand(5)                              # => 4

	rand(5)                              # => 3

	rand(1000)                           # => 39

	a = ['item1', 'item2', 'item3']

	a[rand(a.size)]                      # => "item3"

	m = { :key1 => 'value1',

	      :key2 => 'value2', 

	      :key3 => 'value3' }

	values = m.values

	values[rand(values.size)]            # => "value1"

	def random_word 

	 letters = { ?v => 'aeiou',

	             ?c => 'bcdfghjklmnprstvwyz' }

	 word = '' 

	 'cvcvcvc'.each_byte do |x| 

	   source = letters[x]

	   word << source[rand(source.length)].chr

	 end

	 return word

	end



	random_word                          # => "josuyip" 

	random_word                          # => "haramic"

	#Some random numbers based on process number and current time

	rand(1000)                           # => 187

	rand(1000)                           # => 551

	rand(1000)                           # => 911



	#Start the seed with the number 1

	srand 1

	rand(1000)                           # => 37 

	rand(1000)                           # => 235

	rand(1000)                           # => 908



	#Reset the seed to its previous state

	srand 1

	rand(1000)                           # => 37 

	rand(1000)                           # => 235

	rand(1000)                           # => 908

	0b100                                # => 4

	0o100                                # => 64

	0x100                                # => 256

	"1045".to_i(10)                      # => 1045

	"-1001001".to_i(2)                   # => -73

	"abc".to_i(16)                       # => 2748

	"abc".to_i(20)                       # => 4232

	"number".to_i(36)                    # => 1442151747

	"zz1z".to_i(36)                      # => 1678391

	"abcdef".to_i(16)                    # => 11259375

	"AbCdEf".to_i(16)                    # => 11259375

	42.to_s(10)                          # => "42"

	-100.to_s(2)                         # => "-1100100"

	255.to_s(16)                         # => "ff"

	1442151747.to_s(36)                  # => "number"

	"6".to_i(2)                          # => 0

	"0".to_i(1)                          # ArgumentError: illegal radix 1

	40.to_s(37)                          # ArgumentError: illegal radix 37

	Math.log(1)                          # => 0.0

	Math.log(Math::E)                    # => 1.0

	Math.log(10)                         # => 2.30258509299405

	Math::E ** Math.log(25)              # => 25.0

	Math.log10(1)                          # => 0.0

	Math.log10(10)                         # => 1.0 

	Math.log10(10.1)                       # => 1.00432137378264 

	Math.log10(1000)                       # => 3.0

	10 ** Math.log10(25)                   # => 25.0

	module Math

	  def Math.logb(num, base)

	    log(num) / log(base)

	  end

	end

	dividend = Math.log(2)

	(1..6).collect { |x| Math.log(x) / dividend }

	# => [0.0, 1.0, 1.58496250072116, 2.0, 2.32192809488736, 2.58496250072116]

	def mean(array)

	  array.inject(array.inject(0) { |sum, x| sum += x } / array.size.to_f

	end



	mean([1,2,3,4])                      # => 2.5

	mean([100,100,100,100.1])            # => 100.025

	mean([-100, 100])                    # => 0.0

	mean([3,3,3,3])                      # => 3.00

	def median(array, already_sorted=false)

	  return nil if array.empty?

	  array = array.sort unless already_sorted

	  m_pos = array.size / 2

	  return array.size % 2 == 1 ? array[m_pos] : mean(array[m_pos-1..m_pos])

	end



	median([1,2,3,4,5])                  # => 3

	median([5,3,2,1,4])                  # => 3

	median([1,2,3,4])                    # => 2.5

	median([1,1,2,3,4])                  # => 2

	median([2,3,-100,100])               # => 2.5

	median([1, 1, 10, 100, 1000])        # => 10

	def modes(array, find_all=true)

	  histogram = array.inject(Hash.new(0)) { |h, n| h[n] += 1; h }

	  modes = nil

	  histogram.each_pair do |item, times|

	    modes << item if modes && times == modes[0] and find_all

	    modes = [times, item] if (!modes && times>1) or (modes && times>modes[0])

	  end

	  return modes ? modes[1…modes.size] : modes

	end



	modes([1,2,3,4])                     # => nil

	modes([1,1,2,3,4])                   # => [1]

	modes([1,1,2,2,3,4])                 # => [1, 2]

	modes([1,1,2,2,3,4,4])               # => [1, 2, 4]

	modes([1,1,2,2,3,4,4], false)        # => [1]

	modes([1,1,2,2,3,4,4,4,4,4])         # => [4]

	class Numeric

	  def degrees

	    self * Math::PI / 180 

	  end

	end

	90.degrees                           # => 1.5707963267949

	Math::tan(45.degrees)                # => 1.0

	Math::cos(90.degrees)                # => 6.12303176911189e-17

	Math::sin(90.degrees)                # => 1.0

	Math::sin(89.9.degrees)              # => 0.999998476913288



	Math::sin(45.degrees)                # => 0.707106781186547

	Math::cos(45.degrees)                # => 0.707106781186548

	require 'rubygems' 

	require 'units/base'



	class Numeric

	  remove_method(:degrees) # Remove the implementation given in the Solution

	  add_unit_conversions(:angle => { :radians => 1, :degrees => Math::PI/180 })

	  add_unit_aliases(:angle => { :degrees => [:degree], :radians => [:radian] })

	end



	90.degrees                           # => 90.0

	90.degrees.unit                      # => :degrees

	90.degrees.to_radians                # => 1.5707963267949

	90.degrees.to_radians.unit           # => :radians



	1.degree.to_radians                  # => 0.0174532925199433

	1.radian.to_degrees                  # => 57.2957795130823

	require ' 

matrix'

	require 'mathn'



	a1 = [[1, 1, 0, 1],

	      [2, 0, 1, 2],

	      [3, 1, 1, 2]]

	m1 =  

Matrix[*a1]

	# =>  

Matrix[[1, 1, 0, 1], [2, 0, 1, 2], [3, 1, 1, 2]]



	a2 = [[1, 0],

	      [3, 1], 

	      [1, 0], 

	      [2, 2.5]] 

	m2 = Matrix[*a2]

	# => Matrix[[1, 0], [3, 1], [1, 0], [2, 2.5]]



	m1 * m2

	# => Matrix[[6, 3.5], [7, 5.0], [11, 6.0]]

	2x + 10y + 8z = 54 

	7y + 4z = 30 

	5x + 5y + 5z = 35

	require 'matrix'

	require 'rational' 

	coefficients = [[2, 10, 8], [0, 7, 4], [5, 5, 5]].collect! do |row|

	  row.collect! { |x| Rational(x) }

	end

	coefficients = Matrix[*coefficients]

	# => Matrix[[Rational(2, 1), Rational(10, 1), Rational(8, 1)],

	# =>        [Rational(0, 1), Rational(7, 1), Rational(4, 1)],

	# =>        [Rational(5, 1), Rational(5, 1), Rational(5, 1)]]



	constants = Matrix[[Rational(54)], [Rational(30)], [Rational(35)]]

	solutions = coefficients.inverse * constants

	# => Matrix[[Rational(1, 1)], [Rational(2, 1)], [Rational(4, 1)]]

	require 'complex'



	Complex::I                      # => Complex(0, 1)



	a = Complex(1, 4)               # => Complex(1, 4)

	a.real                          # => 1

	a.image                         # => 4



	b = Complex(1.5, 4.25)          # => Complex(1.5, 4.25)

	b + 1.5                         # => Complex(3.0, 4.25)

	b + 1.5*Complex::I              # => Complex(1.5, 5.75)



	a - b                           # => Complex(-0.5, -0.25)

	a * b                           # => Complex(-15.5, 10.25)

	b.conjugate                     # => Complex(1.5, -4.25)

	Math::sin(b)                    # => Complex(34.9720129257216, 2.47902583958724)

	class Mandelbrot



	  # Set up the Mandelbrot generator with the basic parameters for

	  # deciding whether or not a point is in the set.



	  def initialize(bailout=10, iterations=100)

	    @bailout, @iterations = bailout, iterations

	  end

	require 'delegate'

	class HexNumber < DelegateClass( 

Fixnum)

	  # The string representations of this class are hexadecimal numbers

	  def to_s

	    sign = self < 0 ? "-" : ""

	    hex = abs.to_s(16)

	    "#{sign}0x#{hex}"

	  end



	  def inspect

	    to_s

	  end

	end



	HexNumber.new(10)                  # => 0xa

	HexNumber.new(-10)                 # => -0xa

	HexNumber.new(1000000)             # => 0xf4240

	HexNumber.new(1024 ** 10)          # => 0x10000000000000000000000000



	HexNumber.new(10).succ             # => 11

	HexNumber.new(10) * 2              # => 20

	class Roman

	  # These arrays map all distinct substrings of Roman numbers

	  # to their Arabic equivalents, and vice versa.

	  @@roman_to_arabic = [['M', 1000], ['CM', 900], ['D', 500], ['CD', 400],

	    ['C', 100], ['XC', 90], ['L', 50], ['XL', 40], ['X', 10], ['IX', 9],

	    ['V', 5], ['IV', 4], ['I', 1]]

	  @@arabic_to_roman = @@roman_to_arabic.collect { |x| x.reverse }.reverse



	  # The Roman symbol for 5000 (a V with a bar over it) is not in

	  # ASCII nor Unicode, so we won't represent numbers larger than 3999.

	  MAX = 3999



	  def initialize(number)

	    if number.respond_to? :to_str

	      @value = Roman.to_arabic(number)

	    else

	      Roman.assert_within_range(number)

	      @value = number

	    end

	  end



	  # Raise an exception if a number is too large or small to be represented

	  # as a 

Roman number.

	  def  

Roman.assert_within_range(number)

	    unless number.between?(1, MAX)

	      msg = "#{number} can't be represented as a Roman number."

	      raise RangeError.new(msg)

	    end

	  end



	  #Find the Fixnum value of a string containing a Roman number.

	  def Roman.to_arabic(s)

	    value = s

	    if s.respond_to? :to_str

	      c = s.dup

	      value = 0

	      invalid = ArgumentError.new("Invalid Roman number: #{s}")

	      value_of_previous_number = MAX+1

	      value_from_previous_number = 0

	      @@roman_to_arabic.each_with_index do |(roman, arabic), i|

	        value_from_this_number = 0

	        while c.index(roman) == 0

	          value_from_this_number += arabic

	          if value_from_this_number >= value_of_previous_number

	            raise invalid

	          end

	          c = c[roman.size..s.size]

	        end



	        #This one's a little tricky. We reject numbers like "IVI" and

	        #"IXV", because they use the subtractive notation and then

	        #tack on a number that makes the total overshoot the number

	        #they'd have gotten without using the subtractive

	        #notation. Those numbers should be V and XIV, respectively.

	        if i > 2 and @@roman_to_arabic[i-1][0].size > 1 and

	            value_from_this_number + value_from_previous_number >=

	            @@roman_to_arabic[i-2][1]

	          raise invalid

	        end



	        value += value_from_this_number

	        value_from_previous_number = value_from_this_number

	        value_of_previous_number = arabic

	        break if c.size == 0

	      end

	      raise invalid if c.size > 0

	    end

	    return value

	  end



	  def to_arabic

	    @value

	  end

	  #Render a Fixnum as a string depiction of a  

Roman number

	  def to_ 

roman

	    value = to_arabic

	    Roman.assert_within_range(value)

	    repr = ""

	    @@arabic_to_roman.reverse_each do |arabic, roman|

	      num, value = value.divmod(arabic)

	      repr << roman * num

	    end

	    repr

	  end

	def fibonacci(limit = nil)

	  seed1 = 0

	  seed2 = 1

	  while not limit or seed2 <= limit

	    yield seed2

	    seed1, seed2 = seed2, seed1 + seed2

	  end

	end



	fibonacci(3) { |x| puts x }

	# 1

	# 1

	# 2

	# 3



	fibonacci(1) { |x| puts x }

	# 1

	# 1



	fibonacci { |x| break if x > 20; puts x }

	# 1

	# 1

	# 2

	# 3

	# 5

	# 8

	# 13

	class Range

	  def each_slow

	    x = self.begin

	    while x <= self.end

	      yield x

	      x = x.succ

	    end

	  end

	end



	(1..3).each_slow {|x| puts x} 

	# 1

	# 2

	# 3

	class Fixnum

	  def double_upto(stop)

	    x = self

	    until x > stop

	      yield x

	    x = x * 2

	   end

	  end

	end

	10.double_upto(50) { |x| puts x }

	# 10

	# 20

	# 40

	require 'mathn' 

	primes = Prime.new 

	primes.succ                               # => 2 

	primes.succ                               # => 3

	primes.each { |x| puts x; break if x > 15; }

	# 5

	# 7

	# 11

	# 13

	# 17

	primes.succ                              # => 19

	def sieve(max=100)

	  sieve = []

	  (2..max).each { |i| sieve[i] = i }

	  (2..Math.sqrt(max)).each do |i|

	    (i*i).step(max, i) { |j| sieve[j] = nil } if sieve[i]

	  end

	  sieve.compact

	end



	sieve(10)

	# => [2, 3, 5, 7]

	sieve(100000).size

	# => 9592

	require 'rubygems' 

	require 'creditcard'



	'5276 4400 6542 1319'.creditcard?    # => true

	'5276440065421313'.creditcard?       # => false

	1276440065421319.creditcard?         # => false

	5276440065421313.creditcard_type     # => "mastercard"

	module CreditCard

	  def creditcard?

	    numbers = self.to_s.gsub(/[^\d]+/, '').split(//)



	    checksum = 0

	    0.upto numbers.length do |i|

	      weight = numbers[-1*(i+2)].to_i * (2 - (i%2))



	      checksum += weight % 9

	    end



	    return numbers[-1].to_i == 10 - checksum % 10

	  end

	end



	class String

	  include CreditCard

	end



	class Integer

	  include CreditCard

	end



	'5276 4400 6542 1319'.creditcard?      # => true

	numbers = '5276 4400 6542 1319'.gsub(/[^\d]+/, '').split(//)

	# =>  ["5", "2", "7", "6", "4", "4", "0", "0",

	# =>  "6", "5", "4", "2", "1", "3", "1", "9"]

	checksum = 0

	0.upto numbers.length do |i|

	  weight = numbers[-1*(i+2)].to_i * (2 - (i%2))

	  checksum += weight % 9

	end

	checksum                              # => 51

	now = 

Time.now                    # => Sat Mar 18 16:58:07 EST 2006

	now.gmtime                        # => Sat Mar 18 21:58:07 UTC 2006



	#The original object was affected by the time zone conversion.

	now                               # => Sat Mar 18 21:58:07 UTC 2006

	require 'date'

	now = DateTime.now

	# => #<DateTime: 70669826362347677/28800000000,-5/24,2299161>

	now.to_s                          # => "2006-03-18T16:58:07-0500"

	now.new_offset.to_s               # => "2006-03-18T21:58:07Z"



	#The original object was not affected by the time zone conversion.

	now.to_s                          # => "2006-03-18T16:58:07-0500"

	now_time = Time.new

	now_datetime = DateTime.now

	now_time.year                      # => 2006

	now_ 

datetime.year                  # => 2006

	now_time.hour                      # => 18

	now_ 

datetime.hour                  # => 18



	now_time.zone                      # => "EST"

	now_ 

datetime.zone                  # => "-0500"

	now_time.isdst                     # => false

	require 'date'



	Date. 

parse('2/9/2007').to_s

	# => "2007-02-09"



	 

DateTime.parse('02-09-2007 12:30:44 AM').to_s

	# => "2007-09-02T00:30:44Z"



	DateTime. 

parse('02-09-2007 12:30:44 PM EST').to_s

	# => "2007-09-02T12:30:44-0500"



	 

Date.parse('Wednesday, January 10, 2001').to_s

	# => "2001-01-10"

	Date.parse('2/9/07').to_s                   # => "0007-02-09"

	american_date = '%m/%d/%y'

	Date.strptime('2/9/07', american_date).to_s            # => "2007-02-09"

	DateTime.strptime('2/9/05', american_date).to_s        # => "2005-02-09T00:00:00Z"

	Date.strptime('2/9/68', american_date).to_s            # => "2068-02-09"

	Date.strptime('2/9/69', american_date).to_s            # => "1969-02-09"



	european_date = '%d/%m/%y'

	Date.strptime('2/9/07', european_date).to_s            # => "2007-09-02"

	Date.strptime('02/09/68', european_date).to_s          # => "2068-09-02"

	Date.strptime('2/9/69', european_date).to_s            # => "1969-09-02"



	four_digit_year_date = '%m/%d/%Y'

	Date.strptime('2/9/2007', four_digit_year_date).to_s   # => "2007-02-09"

	Date.strptime('02/09/1968', four_digit_year_date).to_s # => "1968-02-09"

	Date.strptime('2/9/69', four_digit_year_date).to_s     # => "0069-02-09"



	date_and_time = '%m-%d-%Y %H:%M:%S %Z'

	DateTime.strptime('02-09-2007 12:30:44 EST', date_and_time).to_s

	# => "2007-02-09T12:30:44-0500"

	DateTime.strptime('02-09-2007 12:30:44 PST', date_and_time).to_s

	# => "2007-02-09T12:30:44-0800"

	DateTime.strptime('02-09-2007 12:30:44 GMT', date_and_time).to_s

	# => "2007-02-09T12:30:44Z"



	twelve_hour_clock_time = '%m-%d-%Y %I:%M:%S %p'

	DateTime.strptime('02-09-2007 12:30:44 AM', twelve_hour_clock_time).to_s

	# => "2007-02-09T00:30:44Z"

	DateTime.strptime('02-09-2007 12:30:44 PM', twelve_hour_clock_time).to_s

	# => "2007-02-09T12:30:44Z"



	word_date = '%A, %B %d, %Y'

	Date.strptime('Wednesday, January 10, 2001', word_date).to_s

	# => "2001-01-10"

	require 'date'

	Time.now.to_s                               # => "Sat Mar 18 19:05:50 EST 2006"

	DateTime.now.to_s                           # => "2006-03-18T19:05:50-0500"

	Time.gm(2006).strftime('The year is %Y!')   # => "The year is 2006!"

	time = Time.gm(2005, 12, 31, 13, 22, 33)

	american_date = '%D'

	time.strftime(american_date)                # => "12/31/05"

	european_date = '%d/%m/%y'

	time.strftime(european_date)                # => "31/12/05"

	four_digit_year_date = '%m/%d/%Y'

	time.strftime(four_digit_year_date)         # => "12/31/2005"

	date_and_time = '%m-%d-%Y %H:%M:%S %Z'

	time.strftime(date_and_time)                # => "12-31-2005 13:22:33 GMT"

	twelve_hour_clock_time = '%m-%d-%Y %I:%M:%S %p'

	time.strftime(twelve_hour_clock_time)       # => "12-31-2005 01:22:33 PM"

	word_date = '%A, %B %d, %Y'

	time.strftime(word_date)                    # => "Saturday, December 31, 2005"

	require 'date'

	(Date.new(1776, 7, 2)..Date.new(1776, 7, 4)).each { |x| puts x }

	# 1776-07-02

	# 1776-07-03

	# 1776-07-04



	span = DateTime.new(1776, 7, 2, 1, 30, 15)..DateTime.new(1776, 7, 4, 7, 0, 0)

	span.each { |x| puts x }

	# 1776-07-02T01:30:15Z

	# 1776-07-03T01:30:15Z

	# 1776-07-04T01:30:15Z



	(Time.at(100)..Time.at(102)).each { |x| puts x }

	# Wed Dec 31 19:01:40 EST 1969

	# Wed Dec 31 19:01:41 EST 1969

	# Wed Dec 31 19:01:42 EST 1969

	the_first = Date.new(2004, 1, 1)

	the_fifth = Date.new(2004, 1, 5)



	the_first.upto(the_fifth) { |x| puts x }

	# 2004-01-01

	# 2004-01-02

	# 2004-01-03

	# 2004-01-04

	# 2004-01-05

	class Time

	  def step(other_time, increment)

	   raise ArgumentError, "step can't be 0" if increment == 0

	    increasing = self < other_time

	    if (increasing && increment < 0) || (!increasing && increment > 0)

	      yield self

	      return

	      end

	      d = self

	      begin

	        yield d

	        d += increment

	      end while (increasing ? d <= other_time : d >= other_time)

	    end



	    def upto(other_time)

	      step(other_time, 1) { |x| yield x }

	    end

	  end



	  the_first = Time.local(2004, 1, 1)

	  the_second = Time.local(2004, 1, 2)

	  the_first.step(the_second, 60 * 60 * 6) { |x| puts x }

	  # Thu Jan 01 00:00:00 EST 2004

	  # Thu Jan 01 06:00:00 EST 2004

	  # Thu Jan 01 12:00:00 EST 2004

	  # Thu Jan 01 18:00:00 EST 2004

	  # Fri Jan 02 00:00:00 EST 2004



	  the_first.upto(the_first) { |x| puts x }

	  # Thu Jan 01 00:00:00 EST 2004

	require 'date'

	y2k = Time.gm(2000, 1, 1)                   # => Sat Jan 01 00:00:00 UTC 2000

	y2k + 1                                     # => Sat Jan 01 00:00:01 UTC 2000

	y2k - 1                                     # => Fri Dec 31 23:59:59 UTC 1999

	y2k + (60 * 60 * 24 * 365)                  # => Sun Dec 31 00:00:00 UTC 2000



	y2k_dt = DateTime.new(2000, 1, 1)

	(y2k_dt + 1).to_s                           # => "2000-01-02T00:00:00Z"

	(y2k_dt - 1).to_s                           # => "1999-12-31T00:00:00Z"

	(y2k_dt + 0.5).to_s                         # => "2000-01-01T12:00:00Z"

	(y2k_dt + 365).to_s                         # => "2000-12-31T00:00:00Z"

	day_one = Time.gm(1999, 12, 31)

	day_two = Time.gm(2000, 1, 1)

	day_two - day_one                           # => 86400.0

	day_one - day_two                           # => -86400.0



	day_one = DateTime.new(1999, 12, 31)

	day_two = DateTime.new(2000, 1, 1)

	day_two - day_one                           # => Rational(1, 1)

	day_one - day_two                           # => Rational(-1, 1)



	# Compare times from now and 10 seconds in the future.

	before_time = Time.now

	before_datetime = DateTime.now

	sleep(10)

	Time.now - before_time                      # => 10.003414

	DateTime.now - before_datetime              # => Rational(5001557, 43200000000)

	require 'rubygems'

	require 'active_support'



	10.days.ago                                 # => Wed Mar 08 19:54:17 EST 2006

	1.month.from_now                            # => Mon Apr 17 20:54:17 EDT 2006

	2.weeks.since(Time.local(2006, 1, 1))       # => Sun Jan 15 00:00:00 EST 2006



	y2k - 1.day                                 # => Fri Dec 31 00:00:00 UTC 1999

	y2k + 6.3.years                             # => Thu Apr 20 01:48:00 UTC 2006

	6.3.years.since y2k                         # => Thu Apr 20 01:48:00 UTC 2006

	def last_modified(file)

	  t1 = File.stat(file).ctime

	  t2 = Time.now

	  elapsed = (t2-t1)/(60*60*24)

	  puts "#{file} was last modified #{elapsed} 

days ago."

	end

	

	last_modified("/etc/passwd")

	# /etc/passwd was last modified 125.873605469919 days ago.

	last_modified("/home/leonardr/")

	# /home/leonardr/ was last modified 0.113293513796296 days ago.

	require 'date'

	def advent_calendar(date=DateTime.now)

	  christmas = DateTime.new(date.year, 12, 25)

	  christmas = DateTime.new(date.year+1, 12, 25) if date > christmas

	  difference = (christmas-date).to_i

	  if difference == 0

	    puts "Today is Christmas."

	  else

	    puts "Only #{difference} day#{"s" unless difference==1} until Christmas."

	  end

	end



	advent_calendar(DateTime.new(2006, 12, 24))

	# Only 1 day until Christmas.

	advent_calendar(DateTime.new(2006, 12, 25))

	# Today is Christmas.

	advent_calendar(DateTime.new(2006, 12, 26))

	# Only 364 days until Christmas.

	sent = DateTime.new(2006, 10, 4, 3, 15)

	received = DateTime.new(2006, 10, 5, 16, 33)

	elapsed = (received-sent) * 24

	puts "You responded to my email #{elapsed.to_f} hours after I sent it."

	# You responded to my email 37.3 hours after I sent it.

	now = Time.now       # => Sat Mar 18 20:15:58 EST 2006

	now = now.gmtime               # => Sun Mar 19 01:15:58 UTC 2006

	now = now.localtime            # => Sat Mar 18 20:15:58 EST 2006

	require 'date'

	local = DateTime.now

	local.to_s                     # => "2006-03-18T20:15:58-0500"

	utc = local.new_offset(0)

	utc.to_s                       # => "2006-03-19T01:15:58Z"

	local = DateTime.now

	utc = local.new_offset



	local.offset                  # => Rational(-5, 24)

	local_from_utc = utc.new_offset(local.offset)

	local_from_utc.to_s           # => "2006-03-18T20:15:58-0500"

	local == local_from_utc       # => true

	Time.local(2006, 1, 1)                 # => Sun Jan 01 00:00:00 EST 2006

	Time.local(2006, 1, 1). 

isdst           # => false

	Time.local(2006, 10, 1)                # => Sun Oct 01 00:00:00 EDT 2006

	Time.local(2006, 10, 1).isdst          # => true

	eastern = Time.local(2006, 10, 1)      # => Sun Oct 01 00:00:00 EDT 2006

	eastern.isdst                          # => true



	ENV['TZ'] = 'US/Pacific'

	pacific = Time.local(2006, 10, 1)      # => Sun Oct 01 00:00:00 PDT 2006

	pacific.isdst                          # => true

	

	# Except for the Navajo Nation, Arizona doesn't use Daylight Saving Time.

	ENV['TZ'] = 'America/Phoenix'

	arizona = Time.local(2006, 10, 1)      # => Sun Oct 01 00:00:00 MST 2006

	arizona.isdst                          # => false



	# Finally, restore the original time zone.

	ENV['TZ'] = nil

	# Daylight saving first took effect on March 31, 1918.

	Time.local(1918, 3, 31).isdst         # => false

	Time.local(1918, 4, 1).isdst          # => true

	Time.local(1919, 4, 1).isdst          # => true



	# The federal law was repealed later in 1919, but some places

	# continued to use 

Daylight Saving Time.

	ENV['TZ'] = 'US/Pacific'

	Time.local(1920, 4, 1)                # => Thu Apr 01 00:00:00 PST 1920



	ENV['TZ'] = nil

	Time.local(1920, 4, 1)                # => Thu Apr 01 00:00:00 EDT 1920



	# Daylight Saving Time was reintroduced during the Second World War.

	Time.local(1942,2,9)                  # => Mon Feb 09 00:00:00 EST 1942

	Time.local(1942,2,10)                 # => Tue Feb 10 00:00:00 EWT 1942

	# EWT stands for "Eastern War Time"

	require 'date'

	class Time

	  def to_datetime

	    # Convert seconds + microseconds into a fractional number of seconds

	    seconds = sec + Rational(usec, 10**6)



	    # Convert a UTC offset measured in minutes to one measured in a

	    # fraction of a day.

	    offset = Rational(utc_offset, 60 * 60 * 24)

	    DateTime.new(year, month, day, hour, min, seconds, offset)

	  end

	end



	time = Time.gm(2000, 6, 4, 10, 30, 22, 4010)

	# => Sun Jun 04 10:30:22 UTC 2000

	time.to_datetime.to_s

	# => "2000-06-04T10:30:22Z"

	class Date

	  def to_gm_time

	    to_time(new_offset, :gm)

	  end



	  def to_local_time

	    to_time(new_offset(DateTime.now.offset-offset), :local)

	  end



	  private

	  def to_time(dest, method)

	    #Convert a fraction of a day to a number of microseconds

	    usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i

	    Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min,

	              dest.sec, usec)

	  end

	end



	(datetime = DateTime.new(1990, 10, 1, 22, 16, Rational(41,2))).to_s

	# => "1990-10-01T22:16:20Z"

	datetime.to_gm_time

	# => Mon Oct 01 22:16:20 UTC 1990

	datetime.to_local_time

	# => Mon Oct 01 17:16:20 EDT 1990

	def every_sunday(d1, d2)

	  # You can use 1.day instead of 60*60*24 if you're using Rails.

	  one_day = d1.is_a?(Time) ? 60*60*24 : 1

	  sunday = d1 + ((7-d1.wday) % 7) * one_day

	  while sunday < d2

	    yield sunday

	    sunday += one_day * 7

	  end

	end



	def print_every_sunday(d1, d2)

	  every_sunday(d1, d2) { |sunday| puts sunday.strftime("%x")}

	end



	print_every_sunday(Time.local(2006, 1, 1), Time.local(2006, 2, 4))

	# 01/01/06

	# 01/08/06

	# 01/15/06

	# 01/22/06

	# 01/29/06

	t = Time.local(2006, 1, 1)

	t.strftime("%A %A %A!")                    # => "Sunday Sunday Sunday!"

	t.strftime("%a %a %a!")                    # => "Sun Sun Sun!"

	require 'date'

	sunday = DateTime.new(2006, 1, 1)

	sunday.year                                # => 2006

	sunday.cwyear                              # => 2005

	sunday.cweek                               # => 52

	sunday.wday                                # => 0

	sunday.cwday                               # => 7

	monday = sunday + 1

	monday.cwyear                              # => 2006

	monday.cweek                               # => 1

	(sunday…sunday+7).each do |d|

	  puts "#{d.strftime("%a")} #{d.wday} #{d.cwday}"

	end

	# Sun 0 7

	# Mon 1 1

	# Tue 2 2

	# Wed 3 3

	# Thu 4 4

	# Fri 5 5

	# Sat 6 6

	def every_n_seconds(n)

	  loop do

	    before = Time.now

	    yield

	    interval = n-(Time.now-before)

	    sleep(interval) if interval > 0

	  end

	end

	every_n_seconds(5) do

	 puts "At the beep, the time will be #{Time.now.strftime("%X")}…beep!"

	end

	# At the beep, the time will be 12:21:28… beep!

	# At the beep, the time will be 12:21:33… beep!

	# At the beep, the time will be 12:21:38… beep!

	# …

	def every_n_seconds(n)

	  loop do

	    yield

	    sleep(n)

	  end

	end

	def every_n_seconds(n)

	  thread = Thread.new do

	    while true

	      before = Time.now

	      yield

	      interval = n-(Time.now-before)

	      sleep(interval) if interval > 0

	    end

	  end

	  return thread

	end

	3.downto(1) { |i| puts "#{i}…"; sleep(1) }; puts "Go!"

	# 3…

	# 2…

	# 1…

	# Go!



	Time.new                     # => Sat Mar 18 21:17:58 EST 2006

	sleep(10)

	Time.new                     # => Sat Mar 18 21:18:08 EST 2006

	sleep(1)

	Time.new                     # => Sat Mar 18 21:18:09 EST 2006

	# Sleep for less then a second.

	Time.new.usec                # => 377185

	sleep(0.1)

	Time.new.usec                # => 479230

	# This code will sleep forever… OR WILL IT?

	require 'timeout'

	before = Time.now

	begin

	  status = Timeout.timeout(5) { sleep }

	rescue Timeout::Error

	  puts "I only slept for #{Time.now-before} seconds."

	end

	# I only slept for 5.035492 seconds.

	def count_for_five_seconds

	  $counter = 0

	  begin

	    Timeout::timeout(5) { loop { $counter += 1 } }

	  rescue Timeout::Error

	    puts "I can count to #{$counter} in 5 seconds."

	  end

	end



	count_for_five_seconds

	# I can count to 2532825 in 5 seconds.

	$counter                                 # => 2532825

	[1, 2, 3, 4].each { |x| puts x }

	# 1

	# 2

	# 3

	# 4

	[1, 2, 3, 4].collect { |x| x ** 2 }             # => [1, 4, 9, 16]

	['a', 'b', 'c'].each_with_index do |item, index|

	  puts "At position #{index}: #{item}"

	end

	# At position 0: a

	# At position 1: b

	# At position 2: c

	a = 1

	b = 2

	a, b = b, a

	a                                  # => 2

	b                                  # => 1

	a, b, c = :red, :green, :blue

	c, a, b = a, b, c

	a                                  # => :green

	b                                  # => :blue

	c                                  # => :red

	array = [:red, :green, :blue]

	c, a, b = array

	a                                  # => :green

	b                                  # => :blue

	c                                  # => :red

	a, b, *c = [12, 14, 178, 89, 90]

	a                                   # => 12

	b                                   # => 14

	c                                   # => [178, 89, 90]

	a, b = 1, 2

	x = a

	a = b

	b = x

	a, b = 5, 10

	a, b = b/a, a-1                      # => [2, 4]



	a, b, c = 'A', 'B', 'C'

	a, b, c = [a, b], { b => c }, a

	a                                    # => ["A", "B"]

	b                                    # => {"B"=>"C"}

	c                                    # => "A"

	survey_results = [1, 2, 7, 1, 1, 5, 2, 5, 1]

	distinct_answers = survey_results.uniq        # => [1, 2, 7, 5]

	survey_results.uniq!

	survey_results                                # => [1, 2, 7, 5]

	require 'set'

	survey_results = [1, 2, 7, 1, 1, 5, 2, 5, 1]

	distinct_answers = survey_results.to_set

	# => #<Set: {5, 1, 7, 2}>



	games = [["Alice", "Bob"], ["Carol", "Ted"],

	         ["Alice", "Mallory"], ["Ted", "Bob"]]

	players = games.inject(Set.new) { |set, game| game.each { |p| set << p }; set }

	# => #<Set: {"Alice", "Mallory", "Ted", "Carol", "Bob"}>



	players << "Ted"

	# => #<Set: {"Alice", "Mallory", "Ted", "Carol", "Bob"}>

	[1,2,3].reverse                           # => [3, 2, 1]

	[1,[2,3,4],5].reverse                     # => [5, [2, 3, 4], 1]

	a = [1,2,3]

	a. 

reverse!

	a                                       # => [3, 2, 1]

	[5.01, -5, 0, 5].sort                                # => [-5, 0, 5, 5.01] 

	["Utahraptor", "Ankylosaur", "Maiasaur"].sort

	# => ["Ankylosaur", "Maiasaur", "Utahraptor"]

	arrays = [[1,2,3], [100], [10,20]]  

	arrays.sort_by { |x| x.size }                    # => [[100], [10, 20], [1, 2, 3]]

	[1, 100, 42, 23, 26, 10000].sort do |x, y|

	  x == 42 ? 1 : x <=> y

	end

	# => [1, 23, 26, 100, 10000, 42]

	class Animal

	 attr_reader :name, :eyes, :appendages



	 def initialize(name, eyes, appendages)

	  @name, @eyes, @appendages = name, eyes, appendages

	 end



	 def inspect

	   @name

	 end

	end



	animals = [Animal.new("octopus", 2, 8),

	           Animal.new("spider", 6, 8),

	           Animal.new("bee", 5, 6),

	           Animal.new("elephant", 2, 4),

	           Animal.new("crab", 2, 10)]



	animals.sort_by { |x| x.eyes }

	# => [octopus, elephant, crab, bee, spider]



	animals.sort_by { |x| x.appendages }

	# => [elephant, bee, octopus, spider, crab]

	list = ["Albania", "anteater", "zorilla", "Zaire"]

	list.sort

	# => ["Albania", "Zaire", "anteater", "zorilla"]

	list.sort_by { |x| x.downcase }

	# => ["Albania", "anteater", "Zaire", "zorilla"]

	list.collect { |s| [s.downcase, s] }. 

sort.collect { |subarray| subarray[1] }

	m = {}  

	list.sort { |x,y| (m[x] ||= x.downcase) <=> (m[y] ||= y.downcase) }

	class 

SortedArray < Array



	  def initialize(*args, &sort_by)

	    @sort_by = sort_by || Proc.new { |x,y| x <=> y }

	    super(*args)

	    sort! &sort_by

	  end



	  def insert(i, v)

	    # The next line could be further optimized to perform a

	    # binary search.

	    insert_before = index(find { |x| @sort_by.call(x, v) == 1 })

	    super(insert_before ? insert_before : -1, v)

	  end



	  def <<(v)

	    insert(0, v)

	  end



	  alias push <<

	  alias unshift <<

	  ["collect!", "flatten!", "[]="].each do |method_name|

	    module_eval %{

	      def #{method_name}(*args)

	        super

	        sort! &@sort_by

	      end

	    }

	  end



	  def reverse!

	    #Do nothing; reversing the array would disorder it.

	  end

	end

	a = SortedArray.new([3,2,1])         # => [1, 2, 3]

	collection = [1, 2, 3, 4, 5]

	sum = 0 

	collection.each {|i| sum += i} 

	sum                                       # => 15

	collection = [1, 2, 3, 4, 5]

	collection. 

inject(0) {|sum, i| sum + i}      # => 15

	collection = [1, 2, 3, 4, 5]

	sum = 0

	sum = sum + 1

	sum = sum + 2

	sum = sum + 3

	sum = sum + 4

	sum = sum + 5

	collection = [1, 2, 3, 4, 5]

	collection.inject(1) {|total, i| total * i}  # => 120

	module Enumerable

	  def 

sort_by_frequency

	    histogram = inject(Hash.new(0)) { |hash, x| hash[x] += 1; hash}

	    sort_by { |x| [histogram[x], x] }

	  end

	end



	[1,2,3,4,1,2,4,8,1,4,9,16]. 

sort_by_frequency

	# => [3, 8, 9, 16, 2, 2, 1, 1, 1, 4, 4, 4]

	[1,2] <=> [0,2]                        # => 1

	[1,2] <=> [1,2]                        # => 0

	[1,2] <=> [2,2]                        # => -1

	[1,2] <=> [1,1]                        # => 1

	[1,2] <=> [1,3]                        # => -1

	[1,2] <=> [1]                          # => 1

	[1,2] <=> [3]                          # => -1

	[1,2] <=> [0,1,2]                      # => 1

	[1,2] <=> []                           # => 1

	[1,2,3].sort_by { rand } # => [1, 3, 2]

	class Array

	  def shuffle!  

	    each_index do |i| 

	      j = rand(length-i) + i

	      self[j], self[i] = self[i], self[j]  

	    end

	  end



	  def shuffle  

	    dup.shuffle!  

	  end

	end

	class Card

	  def initialize(suit, rank)

	    @suit = suit  

	    @rank = rank  

	  end



	  def to_s

	    "#{@suit} of #{@rank}"

	  end

	end



	class Deck < Array

	  attr_reader :cards  

	  @@suits = %w{Spades Hearts Clubs Diamonds}

	  @@ranks = %w{Ace 2 3 4 5 6 7 8 9 10 Jack Queen King} 



	  def initialize

	    @@suits.each { |suit| @@ranks.each { |rank| self << Card.new(rank, suit) } }

	  end

	end



	deck = Deck.new

	deck.collect { |card| card.to_s }

	# => ["Ace of Spades", "2 of Spades", "3 of Spades", "4 of Spades",…]

	deck.shuffle! 

	deck.collect { |card| card.to_s }

	# => ["6 of Clubs", "8 of Diamonds", "2 of Hearts", "5 of Clubs",…]

	[3, 5, 11, 16].min 

	# => 3

	["three", "five", "eleven", "sixteen"].min

	# => "eleven"

	["three", "five", "eleven", "sixteen"].min { |x,y| x.size <=> y.size }

	# => "five"

	[3, 5, 11, 16].max 

	# => 16

	["three", "five", "eleven", "sixteen"].max

	# => "three"

	["three", "five", "eleven", "sixteen"].max { |x,y| x.size <=> y.size }

	# => "sixteen"

	l = [1, 60, 21, 100, -5, 20, 60, 22, 85, 91, 4, 66]

	sorted = l.sort



	#The top 5

	sorted[-5…sorted.size] 

	# => [60, 66, 85, 91, 100]  



	#The bottom 5 

	sorted[0…5] 

	# => [-5, 1, 4, 20, 21]

	collection = [ [1, 'one'], [2, 'two'], [3, 'three'],

	               [4, 'four'], [5, 'five'] 

	             ]

	

	collection.inject({}) do |hash, value|

	  hash[value.first] = value.last 

	  hash

	end

	# => {5=>"five", 1=>"one", 2=>"two", 3=>"three", 4=>"four"}

	collection.dup.inject({}) { |hash, value| hash[value.first] = value.last }

	# IndexError: index 3 out of string

	Hash.new["key"] = "some value"       # => "some value"

	collection.inject({}) do |hash, value|

	  hash.update value.first => value.last 

	end

	# => {5=>"five", 1=>"ontwo", 2=>"two", 3=>"three", 4=>"four"}

	a = ("a".."h").to_a                # => ["a", "b", "c", "d", "e", "f", "g", "h"]



	a[0]                               # => "a"

	a[1]                               # => "b"



	a.at(1)                            # => "b" 

	a.slice(1)                         # => "b"

	a[-1]                              # => "h"

	a[-2]                              # => "g"

	a[1000]                            # => nil 

	a[-1000]                           # => nil

	a[2..5]                                # => ["c", "d", "e", "f"]

	a[2…5]                               # => ["c", "d", "e"]

	a[0..0]                                # => ["a"]

	a[1..-4]                               # => ["b", "c", "d", "e"]

	a[5..1000]                             # => ["f", "g", "h"]



	a[2..0]                                # => []

	a[0…0]                               # => []



	a[-3..2]                               # => []

	#Union

	[1,2,3] | [1,4,5]                    # => [1, 2, 3, 4, 5] 



	#Intersection

	[1,2,3] & [1,4,5]                    # => [1]



	#Difference

	[1,2,3] - [1,4,5]                    # => [2, 3]

	require 'set' 

	a = [1,2,3]

	b = [3,4,5]

	a.to_set ^ b.to_set                  # => #<Set: {5, 1, 2, 4}>  

	(a | b) - (a & b)                    # => [1, 2, 4, 5]

	array = [1,2,3]

	set = [3,4,5].to_s  

	array & set                      # => TypeError: can't convert Set into Array

	set & array                      # => #<Set: {3}>

	require 'set' 

	s = Set.new((1..10).collect)

	# => #<Set: {5, 6, 1, 7, 2, 8, 3, 9, 4, 10}>



	# Divide the set into the "true" subset and the "false" subset: that

	# is, the "less than 5" subset and the "not less than 5" subset.

	s.divide { |x| x < 5 }

	# => #<Set: {#<Set: {5, 6, 7, 8, 9, 10}>, #<Set: {1, 2, 3, 4}>}>



	# Divide the set into the "0" subset and the "1" subset: that is, the

	# "even" subset and the "odd" subset.

	s.divide { |x| x % 2 }

	# => #<Set: {#<Set: {6, 2, 8, 4, 10}>, #<Set: {5, 1, 7, 3, 9}>}>



	s = Set.new([1, 2, 3, 'a', 'b', 'c', -1.0, -2.0, -3.0])

	# Divide the set into the "String subset, the "Fixnum" subset, and the

	# "Float" subset.

	s.divide { |x| x.class } 

	# => #<Set: {#<Set: {"a", "b", "c"}>,

	# =>       #<Set: {1, 2, 3}>,

	# =>       #<Set: {-1.0, -3.0, -2.0}>}>

	s = [1, 2, 3, -1, -2, -4].to_set



	# Divide the set into sets of numbers with the same absolute value.

	s.divide { |x,y| x.abs == y.abs }

	# => #<Set: {#<Set: {-1, 1}>, 

	# =>         #<Set: {2, -2}>, 

	# =>         #<Set: {-4}>,

	# =>         #<Set: {3}>}>



	# Divide the set into sets of adjacent numbers 

	s.divide { |x,y| (x-y).abs == 1 }

	# => #<Set: {#<Set: {1, 2, 3}>,

	# =>         #<Set: {-1}>,

	# =>         #<Set: {-4, -3}>}>

	people = Hash.new

	people[:nickname] = 'Matz'

	people[:language] = 'Japanese'

	people['last name'.intern] = 'Matsumoto'

	people[:nickname]                                       # => "Matz"

	people['nickname'.intern]                               # => "Matz"

	'name'.object_id                                        # => -605973716

	'name'.object_id                                        # => -605976356

	'name'.object_id                                        # => -605978996

	:name.object_id                                         # => 878862

	:name.object_id                                         # => 878862

	'name'.intern.object_id                                 # => 878862

	'name'.intern.object_id                                 # => 878862

	h = Hash.new

	h[1]                                           # => nil

	h['do you have this string?']                  # => nil

	h = Hash.new("nope")

	h[1]                                          # => "nope"

	h['do you have this string?']                 # => "nope"

	h = Hash.new { |hash, key| (key.respond_to? :to_str) ? "nope" : nil }

	h[1]                                            # => nil

	h['do you have this string']                    # => "nope"

	text = 'The rain in Spain falls mainly in the plain.'

	word_count_hash = Hash.new 0                    # => {}

	text.split(/\W+/).each { |word| word_count_hash[word.downcase] += 1 }

	word_count_hash

	# => {"rain"=>1, "plain"=>1, "in"=>2, "mainly"=>1, "falls"=>1,

	#        "the"=>2, "spain"=>1}

	first_letter_hash = Hash.new []

	text.split(/\W+/).each { |word| first_letter_hash[word[0,1].downcase] << word }

	first_letter_hash

	                                             # => {}

	first_letter_hash["m"]

	# => ["The", "rain", "in", "Spain", "falls", "mainly", "in", "the", "plain"]

	h = {}

	h["Greensleeves"] = "all my joy"

	h                                   # => {"Greensleeves"=>"all my joy"}

	h["Greensleeves"] = "my delight"

	h                                   # => {"Greensleeves"=>"my delight"}

	key = "Modify me if you can"

	h = { key => 1 }

	key.upcase!                         # => "MODIFY ME IF YOU CAN"

	h[key]                              # => nil

	h["Modify me if you can"]           # => 1



	h.keys                              # => ["Modify me if you can"]

	h.keys[0].upcase!

	# TypeError: can't modify frozen string

	squares = [[1,1], [2,4], [3,9]]



	results = {}

	squares.each { |k,v| results[k] = v }

	results                             # => {1=>1, 2=>4, 3=>9}



	squares.inject({}) { |h, kv| h[kv[0]] = kv[1]; h }

	# => {1=>1, 2=>4, 3=>9}

	class Array

	  def into_hash(h)

	    unless size % 2 == 0

	      raise StandardError, "Expected array with even number of elements"

	    end

	    0.step(size-1, 2) { |x| h[self[x]] = self[x+1] }

	    h

	  end

	end



	squares = [1,1,2,3,4,9]

	results = {}

	squares.into_hash(results)            # => {1=>1, 2=>3, 4=>9}



	[1,1,2].into_hash(results)

	# StandardError: Expected array with even number of elements

	h = {}

	h[1] = 10

	h                                          # => {1=>10}

	h.delete(1)

	h                                          # => {}

	h = {}

	h[5]                                         # => nil

	h[5] = 10

	h[5]                                         # => 10

	h[5] = nil

	h[5]                                         # => nil

	h.keys                                       # => [5]

	h.delete(5)

	h.keys                                       # => []

	class Hash

	  def delete_value(value)

	    delete_if { |k,v| v == value }

	  end

	end



	h = {'apple' => 'green', 'potato' => 'red', 'sun' => 'yellow',

	     'katydid' => 'green' }

	h.delete_value('green')

	h                                    # => {"sun"=>"yellow", "potato"=>"red"}

	class Hash

	  def remove_hash(other_hash)

	    delete_if { |k,v| other_hash[k] == v }

	  end

	end



	squares = { 1 => 1, 2 => 4, 3 => 9 }

	doubles = { 1 => 2, 2 => 4, 3 => 6 }

	squares.remove_hash(doubles)

	squares                                  # => {1=>1, 3=>9}

	h = {}

	1.upto(1000) { |x| h[x] = x }

	h.keys.size                              # => 1000

	h.clear

	h                                        # => {}

	coordinates = [10, 5]

	treasure_map = { coordinates => 'jewels' }

	treasure_map[coordinates]                    # => "jewels"



	# Add a z-coordinate to indicate how deep the treasure is buried.

	coordinates << -5



	coordinates                                  # => [10, 5, -5]

	treasure_map[coordinates]                    # => nil

	                                             # Oh no!

	treasure_map.rehash

	treasure_map[coordinates]                    # => "jewels"

	module ReliablyHashable

	 def hash

	    return object_id

	  end

	end



	class ReliablyHashableArray < Array

	  include ReliablyHashable

	end

	coordinates = ReliablyHashableArray.new([10,5])

	treasure_map = { coordinates => 'jewels' }

	treasure_map[coordinates]                       # => "jewels"



	# Add a z-coordinate to indicate how deep the treasure is buried.

	coordinates.push(-5)



	treasure_map[coordinates]                       # => "jewels"

	hash = Hash.new { |hash, key| hash[key] = [] }



	raw_data = [ [1, 'a'], [1, 'b'], [1, 'c'],

	             [2, 'a'], [2, ['b', 'c']],

	             [3, 'c'] ]

	raw_data.each { |x,y| hash[x] << y }

	hash

	# => {1=>["a", "b", "c"], 2=>["a", ["b", "c"]], 3=>["c"]}

	class MultiValuedHash < Hash

	  def []=(key, value)

	    if has_key?(key)

	      super(key, [value, self[key]].flatten)

	    else

	      super

	    end

	   end

	end



	hash = MultiValuedHash.new

	raw_data.each { |x,y| hash[x] = y }

	hash

	# => {1=>["c", "b", "a"], 2=>["b", "c", "a"], 3=>"c"}

	hash = { 1 => 'one', [1,2] => 'two', 'three' => 'three' }



	hash.each_pair { |key, value| puts "#{key.inspect} maps to #{value}"}

	# [1, 2] maps to two

	# "three" maps to three

	# 1 maps to one

	active_toggles = { 'super' => true, 'meta' => true, 'hyper' => true }

	active_toggles.each_key { |active| puts active }

	# hyper

	# meta

	# super

	favorite_colors = { 'Alice' => :red, 'Bob' => :violet, 'Mallory' => :blue,

	                    'Carol' => :blue, 'Dave' => :violet }



	summary = Hash.new 0

	favorite_colors.each_value { |x| summary[x] += 1 }

	summary

	# => {:red=>1, :violet=>2, :blue=>2}

	hash = {}

	1.upto(10) { |x| hash[x] = x * x }

	hash.has_value? 49                    # => true

	hash.has_value? 81                    # => true

	hash.has_value? 50                    # => false

	require ' 

orderedhash'

	h =  

OrderedHash.new

	h[1] = 1

	h["second"] = 2

	h[:third] = 3



	h.keys                                           # => [1, "second", :third]

	h.values                                         # => [1, 2, 3]

	h.each { |k,v| puts "The #{k} counting number is #{v}" }

	# The 1 counting number is 1

	# The second counting number is 2

	# The third counting number is 3

	h = {}

	h[:name] = "Robert"

	h[:nickname] = "Bob"

	h[:age] = 43

	h[:email_addresses] = {:home => "bob@example.com",

	                       :work => "robert@example.com"}

	h

	# => {:email_addresses=>["bob@example.com", "robert@example.com"],

	#         :nickname=>"Bob", :name=>"Robert", :age=>43}

	puts h

	# nicknameBobage43nameRobertemail_addresseshomebob@example.comworkrobert@example.com

	puts h[:email_addresses]

	# homebob@example.comworkrobert@example.com

	p h[:email_addresses]

	# {:home=>"bob@example.com", :work=>"robert@example.com"}

	p h

	# {:nickname=>"Bob", :age=>43, :name=>"Robert", :email_addresses=>{:home=>

	# "bob@example.com", :work=>"robert@example.com"}}

	require ' 

pp'

	pp h[:email_addresses]

	# {:home=>"bob@example.com", :work=>"robert@example.com"}



	pp h

	# {:email_addresses=>{:home=>"bob@example.com", :work=>"robert@example.com"}

	# :nickname=>"Bob",

	# :name=>"Robert",

	# :age=>43}

	phone_directory = {     'Alice' => '555-1212',

	                        'Bob' => '555-1313',

	                        'Mallory' => '111-1111' }

	phone_directory.invert

	# => {"111-1111"=>"Mallory", "555-1212"=>"Alice", "555-1313"=>"Bob"}

	phone_directory = {     'Alice' => '555-1212',

	                        'Bob' => '555-1313',

	                        'Carol' => '555-1313',

	                        'Mallory' => '111-1111',

	                        'Ted' => '555-1212' }

	phone_directory.invert

	# => {"111-1111"=>"Mallory", "555-1212"=>"Ted", "555-1313"=>"Bob"}

	class Hash

	  def safe_invert

	    new_hash = {}

	    self.each do |k,v|

	      if v.is_a? Array

	        v.each { |x| new_hash.add_or_append(x, k) }

	      else

	        new_hash.add_or_append(v, k)

	      end

	    end

	    return new_hash

	  end

	  def add_or_append(key, value)

	    if has_key?(key)

	      self[key] = [value, self[key]].flatten

	    else

	      self[key] = value

	    end

	  end

	end

	phone_directory.safe_invert

	# => {"111-1111"=>"Mallory", "555-1212"=>["Ted", "Alice"],

	# "555-1313"=>["Bob", "Carol"]}



	phone_directory.safe_invert.safe_invert

	# => {"Alice"=>"555-1212", "Mallory"=>"111-1111", "Ted"=>"555-1212",

	# => "Carol"=>"555-1313", "Bob"=>"555-1313"}

	def choose_ 

weighted(weighted)

	  sum = weighted.inject(0) do |sum, item_and_weight|

	    sum += item_and_weight[1]

	  end

	  target = rand(sum)

	  weighted.each do |item, weight|

	    return item if target <= weight

	    target -= weight

	  end

	end

	marbles = { :black => 51, :white => 17 }

	3.times { puts choose_weighted(marbles) }

	# black

	# white

	# black

	lottery_probabilities = { "You've wasted your money!" => 1000,

	                          "You've won back the cost of your ticket!" => 50,

	                          "You've won two shiny zorkmids!" => 20,

	                          "You've won five zorkmids!" => 10,

	                          "You've won ten zorkmids!" => 5,

	                          "You've won a hundred zorkmids!" => 1 }



	# Let's buy some lottery tickets.

	5.times { puts choose_weighted(lottery_probabilities) }

	# You've wasted your money!

	# You've wasted your money!

	# You've wasted your money!

	# You've wasted your money!

	# You've won five zorkmids!

	module Enumerable

	  def to_histogram

	    inject(Hash.new(0)) { |h, x| h[x] += 1; h}

	  end

	end



	[1, 2, 2, 2, 3, 3].to_histogram

	# => {1=>1, 2=>3, 3=>2}



	["a", "b", nil, "c", "b", nil, "a"].to_histogram

	# => {"a"=>2, "b"=>2, "c"=>1, nil=>2}



	"Aye\nNay\nNay\nAbstaining\nAye\nNay\nNot Present\n".to_histogram

	# => {"Abstaining\n"=>1, "Nay\n"=>3, "Not Present\n"=>1, "Aye\n"=>2}



	survey_results = { "Alice" => :red, "Bob" => :green, "Carol" => :green,

	                   "Mallory" => :blue }

	survey_results.values.to_histogram

	# => {:red=>1, :green=>2, :blue=>1}

	def draw_graph(histogram, char="#")

	  pairs = histogram.keys.collect { |x| [x.to_s, histogram[x]] }.sort

	  largest_key_size = pairs.max { |x,y| x[0].size <=> y[0].size }[0].size

	class Hash

	  def tied_with(hash)

	    remap do |h,key,value|

	      h[hash[key]] = value

	    end.delete_if { |key,value| key.nil? || value.nil? }

	  end

	  def remap(hash={})

	    each { |k,v| yield hash, k, v }

	    hash

	  end

	end

	a = {1 => 2, 3 => 4}

	b = {1 => 'foo', 3 => 'bar'}

	a.tied_with(b)                          # => {"foo"=>2, "bar"=>4}

	b.tied_with(a)                          # => {2=>"foo", 4=>"bar"}

	require 'time'

	click_counts = {}

	1.upto(30) { |i| click_counts[Time.parse("2006-09-#{i}")] = 400 + rand(700) }

	p click_counts

	# {Sat Sep 23 00:00:00 EDT 2006=>803, Tue Sep 12 00:00:00 EDT 2006=>829,

	# Fri Sep 01 00:00:00 EDT 2006=>995, Mon Sep 25 00:00:00 EDT 2006=>587,

	# …

	low_click_days = click_counts.select {|key, value| value < 450 }

	# [[Thu Sep 14 00:00:00 EDT 2006, 449], [Mon Sep 11 00:00:00 EDT 2006, 406],

	#  [Sat Sep 02 00:00:00 EDT 2006, 440], [Mon Sep 04 00:00:00 EDT 2006, 431],

	# …

	low_click_days_hash = click_counts.inject({}) do |h, kv|

	  k, v = kv

	  h[k] = v if v < 450

	  h

	end

	# => {Mon Sep 25 00:00:00 EDT 2006=>403,

	#        Wed Sep 06 00:00:00 EDT 2006=>443,

	#        Thu Sep 28 00:00:00 EDT 2006=>419}

	low_click_days_hash = Hash[*low_click_days.flatten]

	# => {Thu Sep 14 00:00:00 EDT 2006=>449, Mon Sep 11 00:00:00 EDT 2006=>406,

	#        Sat Sep 02 00:00:00 EDT 2006=>440, Mon Sep 04 00:00:00 EDT 2006=>431,

	#        …

	h = { "apple tree" => "plant", "ficus" => "plant",

	      "shrew" => "animal", "plesiosaur" => "animal" }

	h.keys.grep /p/

	# => ["apple tree", "plesiosaur"]

	h.inject([]) { |res, kv| res << kv if kv[1] =~ /p/; res }

	# => [["ficus", "plant"], ["apple tree", "plant"]]

	class Hash

	  def grep(pattern)

	    inject([]) do |res, kv|

	      res << kv if kv[0] =~ pattern or kv[1] =~ pattern

	      res

	    end

	  end

	end



	h.grep(/pl/)

	# => [["ficus", "plant"], ["apple tree", "plant"], ["plesiosaur", "animal"]]

	h.grep(/plant/)           # => [["ficus", "plant"], ["apple tree", "plant"]]

	h.grep(/i.*u/)            # => [["ficus", "plant"], ["plesiosaur", "animal"]]

	res = []

	h.each_key { |k| res << k if k =~ /p/ }

	res                   # => ["apple tree", "plesiosaur"]

	filename = 'a_file.txt'

	File.file? filename                           # => false



	require 'fileutils'

	FileUtils.touch(filename)

	File.file? filename                           # => true

	directory_name = 'a_directory'

	FileUtils.mkdir(directory_name)

	File.file? directory_name            # => false 

File.exists? directory_name          # => true

	File.directory? directory_name          # => true

	File.directory? filename                # => false

	File.blockdev? '/dev/hda1'                 # => true

	File.chardev? '/dev/tty1'                  # => true

	File.socket? '/var/run/mysqld/mysqld.sock' # => true

	system('mkfifo named_pipe')

	File.pipe? 'named_pipe'                    # => true

 

File.readable?('/bin/ls')      # => true

	 

File.readable?('/etc/passwd-') # => false



	filename = 'test_file'

	File.open(filename, 'w') {}



	File.writable?(filename) # => true

	File.writable?('/bin/ls') # => false



	 

File.executable?('/bin/ls') # => true

	 

File.executable?(filename) # => false

	File.owned? 'test_file'       # => true

	File.grpowned? 'test_file'    # => true

	File.owned? '/bin/ls'         # => false

	File.lstat('test_file').mode & 0777           # Keep only the permission bits.

	# => 420                                       # That is, 0644 octal.

	class File

	  U_R = 0400

	  U_W = 0200

	  U_X = 0100

	  G_R = 0040

	  G_W = 0020

	  G_X = 0010

	  O_R = 0004

	  O_W = 0002

	  O_X = 0001

	end

	class File

	  A_R = 0444

	  A_W = 0222

	  A_X = 0111

	  end

open("my_file", "w") {}



File.chmod(File::U_R | File::U_W | File::G_R | File::O_R, "my_file")

File.chmod(File::A_R | File::U_W, "my_file")

File.chmod(0644, "my_file")                     # Bitmap: 110001001



File::U_R | File::U_W | File::G_R | File::O_R   # => 420

File::A_R | File::U_W                           # => 420

0644 # => 420

File.lstat("my_file").mode & 0777               # => 420

	open("output", "w") { |f| f << "Here's some output.\n" }

	stat = 

File.stat("output")

	stat.mtime                               # => Thu Mar 23 12:23:54 EST 2006

	stat.atime                               # => Thu Mar 23 12:23:54 EST 2006

	

	sleep(2)

	open("output", "a") { |f| f << "Here's some more output.\n" }

	stat = File.stat("output")

	stat.mtime                               # => Thu Mar 23 12:23:56 EST 2006

	stat.atime                               # => Thu Mar 23 12:23:54 EST 2006

	

	sleep(2)

	open("output") { |f| contents = f.read }

	stat = File.stat("output")

	stat.mtime                               # => Thu Mar 23 12:23:56 EST 2006

	stat.atime                               # => Thu Mar 23 12:23:58 EST 2006

	def save_game(file)

	  score = 1000

	  open(file, "w") do |f|

	    f.puts(score)

	    f.puts(Time.new.to_i)

	  end

	end

	# See the chapter intro to get the create_tree library

	require 'create_tree'

	create_tree 'mydir' =>

	  [ {'subdirectory' => [['file_in_subdirectory', 'Just a simple file.']] },

	  '.hidden_file', 'ruby_script.rb', 'text_file' ] 

Dir.entries('mydir')

	

	# => [".", "..", ".hidden_file", "ruby_script.rb", "subdirectory",

	# "text_file"]

	

	 

Dir.foreach('mydir') { |x| puts x if x != "." && x != ".."}

	# .hidden_file

	# ruby_script.rb

	# subdirectory

	# text_file

	# Find all the "regular" files and subdirectories in mydir. This excludes

	# hidden files, and the special directories . and ..

	Dir["mydir/*"]

	# => ["mydir/ruby_script.rb", "mydir/subdirectory", "mydir/text_file"]

	

	# Find all the .rb files in mydir

	Dir["mydir/*.rb"]                 # =>  ["mydir/ruby_script.rb"]

	Dir.open('mydir') { |d| d.grep /file/ }

	# => [".hidden_file", "text_file"]

	

	Dir.open('mydir') { |d| d.each { |x| puts x } }

	# .

	# ..

	# .hidden_file

	# ruby_script.rb

	# subdirectory

	# text_file

	#Put some stuff into a file.

	open('sample_file', 'w') do |f|

	  f.write("This is line one.\nThis is line two.")

	end

	

	# Then read it back out.

	open('sample_file') { |f| f.read }

	# => "This is line one.\nThis is line two."

	open('sample_file') { |f| f.readlines }

	# => ["This is line one.\n", "This is line two."]

	open('sample_file').each { |x| p x }

	# "This is line one.\n"

	# "This is line two."

	puts open('conclusion') { |f| f.read(50) }

	# "I know who killed Mr. Lambert," said Joe. "It was

	# Create a file…

	open('end_separated_records', 'w') do |f|

	  f << %{This is record one.

	It spans multiple lines.ENDThis is record two.END}

	end

	

	# And read it back in.

	open('end_separated_records') { |f| f.each('END') { |record| p record } }

	# "This is record one.\nIt spans multiple lines.END"

	# "This is record two.END"

	open('output', 'w') { |f| f << "This file contains great truths.\n" }

	open('output', 'w') do |f|

	  f.puts 'The great truths have been overwritten with an advertisement.'

	end

	

	open('output') { |f| f.read }

	# => "The great truths have been overwritten with an advertisement.\n"

	open('output', "a") { |f| f.puts 'Buy Ruby(TM) brand soy sauce!' }

	

	open('output') { |f| puts f.read }

	# The great truths have been overwritten with an advertisement.

	# Buy Ruby(TM) brand soy sauce!

	open('output', 'w') do |f|

	  [1,2,3].each { |i| f << i << ' and a ' }

	end

	open('output') { |f| f.read }     # => "1 and a 2 and a 3 and a "

	require 'tempfile'

	out = Tempfile.new("tempfile")

	out.path # =>              "/tmp/tempfile23786.0"

	out << "Some text."

	out.rewind

	out.read # => "Some text."

	out.close

	out = Tempfile.new("myhome_tempfile", "/home/leonardr/temp/")

	require 'fileutils'

	FileUtils.mv(out.path, "/home/leonardr/old_tempfile")

	module Enumerable

	  def random_line

	    selected = nil

	    each_with_index { |line, lineno| selected = line if rand < 1.0/lineno }

	    return selected.chomp if selected

	  end

	end

	

	#Create a file with 1000 lines

	open('random_line_test', 'w') do |f|

	  1000.times { |i| f.puts "Line #{i}" }

	end

	

	#Pick 

random lines from the file.

	f = open('random_line_test')

	f.random_line # => "Line 520"

	f.random_line # => nil

	f.rewind

	f.random_line # => "Line 727"

	File.open('random_line_test') do |f|

	l = f.readlines

	l[rand(l.size)].chomp

	end

	# => "Line 708"

	$ ruby -e 'rand < 1.0/$. and line = $_ while gets; puts line.chomp if line'

	class File

	  def File.same_contents(p1, p2)

	    return false if File.exists?(p1) != File.exists?(p2)

	    return true if !File.exists?(p1)

	    return true if File.expand_path(p1) == File.expand_path(p2)

	    return false if File.ftype(p1) != File.ftype(p2) ||

	       File.size(p1) != File.size(p2)

	    open(p1) do |f1|

	      open(p2) do |f2|

	        blocksize = f1.lstat.blksize

	        same = true

	        while same && !f1.eof? && !f2.eof?

	          same = f1.read(blocksize) == f2.read(blocksize)

	        end

	        return same

	      end

	    end

	  end

	end

	1.upto(2) do |i|

	  open("output#{i}", 'w') { |f| f << 'x' * 10000 }

	end

	File.same_contents('output1', 'output2')           # => true

	open("output1", 'a') { |f| f << 'x' }

	open("output2", 'a') { |f| f << 'y' }

	File.same_contents('output1', 'output2')           # => false

	

	File.same_contents('nosuchfile', 'output1')        # => false

	File.same_contents('nosuchfile1', 'nosuchfile2')   # => true

	require 'socket'

	require 'stringio'

	

	sock = TCPSocket.open("www.example.com", 80)

	sock.write("GET /\n")

	

	file = StringIO.new(sock.read)

	file.read(10)                                # => "<HTML>\r\n<H"

	file.rewind

	file.read(10)                                # => "<HTML>\r\n<H"

	file.pos = 90

	file.read(15)                                # => " this web page "

	class 

BufferedIO

	  def initialize(io)

	    @buff = StringIO.new

	    @source = io

	    @pos = 0

	  end



	  def read(x=nil)

	    to_read = x ? to_read = x+@buff.pos-@buff.size : nil

	    _append(@source.read(to_read)) if !to_read or to_read > 0

	    @buff.read(x)

	  end



	  def pos=(x)

	   read(x-@buff.pos) if x > @buff.size

	    @buff.pos = x

	  end

	

	  def seek(x, whence=IO::SEEK_SET)

	    case whence

	      when IO::SEEK_SET then self.pos=(x)

	      when IO::SEEK_CUR then self.pos=(@buff.pos+x)

	      when IO::SEEK_END then read; self.pos=(@buff.size-x)

	      # Note: SEEK END reads all the socket data.

	    end

	    pos

	  end



	  # Some methods can simply be delegated to the buffer.

	  ["pos", "rewind", "tell"].each do |m|

	  module_eval "def #{m}\n@buff.#{m}\nend"

	  end



	  private



	    def _append(s)

	  @buff << s

	    @buff.pos -= s.size

	  end

	end

	require 'create_tree'

	create_tree './' =>

	  [ 'file1',

	    'file2',

	         { 'subdir1/' => [ 'file1' ] },

	         { 'subdir2/' => [ 'file1',

	                      'file2',

	                       { 'subsubdir/' => [ 'file1' ] }

	                     ]

	    }

	   ]

	Dir['**/**']

	# => ["file1", "file2", "subdir1", "subdir2", "subdir1/file1",

	#     "subdir2/file1", "subdir2/file2", "subdir2/subsubdir",

	#     "subdir2/subsubdir/file1"]

	require 'find' 

Find.find('./') { |path| puts path }

	# ./

	# ./subdir2

	# ./subdir2/subsubdir

	# ./subdir2/subsubdir/file1

	# ./subdir2/file2

	# ./subdir2/file1

	# ./subdir1

	# ./subdir1/file1

	# ./file2

	# ./file1

	  def flock(file, mode)

	    success = file.flock(mode)

	    if success

	      begin

	        yield file

	      ensure

	        file.flock(File::LOCK_UN)

	    end

	  end

	  return success

	end

	open('output', 'w') do |f|

	  flock(f, File::LOCK_EX) do |f|

	  f << "Kiss me, I've got a write lock on a file!"

	  end

	end

	class File

	  def File.versioned_filename(base, first_suffix='.0')

	    suffix = nil

	    filename = base

	    while File.exists?(filename)

	      suffix = (suffix ? suffix.succ : first_suffix)

	      filename = base + suffix

	    end

	    return filename

	  end

	end

	

	5.times do |i|

	  name = File.versioned_filename('filename.txt')

	  open(name, 'w') { |f| f << "Contents for run #{i}" }

	  puts "Created #{name}"

	end

	# Created filename.txt

	# Created filename.txt.0

	# Created filename.txt.1

	# Created filename.txt.2

	# Created filename.txt.3

	require 'ftools'

	class File

	def File.to_backup(filename, move=false)

	   new_filename = nil

	   if File.exists? filename

	     new_filename = File. 

versioned_filename(filename)

	     File.send(move ? :move : :copy, filename, new_filename)

	   end

 	   return new_filename

	 end

	end

	    File.to_backup('filename.txt')                  # => "filename.txt.4"

	    File.to_backup('filename.txt')                  # => "filename.txt.5"

	File.to_backup('filename.txt', true)                # => "filename.txt.6"

	File.exists? 'filename.txt'                         # => false

	File.to_backup('filename.txt')                      # => nil

	require 'stringio'

	s = StringIO.new %{I am the very model of a modern major general.

	I've information vegetable, animal, and mineral.}

	

	s.pos                                 # => 0

	s.each_line { |x| puts x }

	# I am the very model of a modern major general.

	# I've information vegetable, animal, and mineral.

	s.eof?                                # => true

	s.pos                                 # => 95

	s.rewind

	s.pos                                 # => 0

	s.grep /general/

	# => ["I am the very model of a modern major general.\n"]

	s = StringIO.new

	s.write('Treat it like a file.')

	s.rewind

	s.write("Act like it's")

	s.string							 # => "Act like it's a file."

	

	require 'yaml'

	s = StringIO.new

	YAML.dump(['A list of', 3, :items], s)

	puts s.string

	# ---

	# - A list of

	# - 3

	# - :items

	#!/usr/bin/ruby -w

	# ./redirect_stdout.rb

	require 'stringio'

	new_stdout = StringIO.new



	$stdout = new_stdout

	puts "Hello, hello."

	puts "I'm writing to standard 

output."



	$stderr.puts "#{new_stdout.size} bytes written to standard ouput so far."

	$stderr.puts "You haven't seen anything on the screen yet, but you soon will:"

	$stderr.puts new_stdout.string

	$ ruby redirect_stdout.rb

	46 bytes written to standard output so far.

	You haven't seen anything on the screen yet, but you soon will:

	Hello, hello.

	I'm writing to standard output.

	open('binary', 'wb') do |f|

	  (0..100).step(10) { |b| f << b.chr }

	end

	

	s = open('binary', 'rb') { |f| f.read }

	# => "\000\n\024\036(2<FPZd"

	open('binary', 'rb') { |f| f.each_byte { |b| puts b } }

	# 0

	# 10

	# 20

	# …

	# 90

	# 100

	f = open('binary')

	f.pos                                     # => 0

	f.read(1)                                 # => "\000"

	f.pos                                     # => 1

	f.pos = 4                                 # => 4

	f.read(2)                                 # => "(2"

	f.pos                                     # => 6

	import 'fileutils'

	FileUtils.touch "doomed_file"

	File.exists? "doomed_file"                    # => true

	File.delete "doomed_file"

	File.exists? "doomed_file"                    # => false

	Dir.mkdir "doomed_directory"

	File.exists? "doomed_directory"            # => true 

FileUtils.remove_dir "doomed_directory"

	File.exists? "doomed_directory"            # => false

	# A hack to make a 

method used by rm_rf actually available

	module FileUtils

	  module_function :fu_world_writable?

	end

	

	Dir.mkdir "/tmp/doomed_directory"

	FileUtils.rm_rf("/tmp/doomed_directory", :secure=>true)

	File.exists? "/tmp/doomed_directory"            # => false

	filename = 'truncate.txt'

	open(filename, 'w') { |f| f << "All of this will be truncated." }

	File.size(filename)                  # => 30

	

	f = open(filename, 'w') {}

	File.size(filename)                  # => 0

	open(filename, 'w') { |f| f << "Here are some new contents." }

	

	File.size(filename)                        # => 27

	

	f = open(filename, File::TRUNC) {}

	File.size(filename)                        # => 0

	open(filename, File::TRUNC) do |f|

	  f << "At last, an empty file to write to!"

	end

	# IOError: not opened for writing

	f = open(filename, 'w') do |f|

	  f << 'These words will remain intact after the file is truncated.'

	end

	File.size(filename) # => 59

	

	File.truncate(filename, 30)

	File.size(filename)              # => 30

	open(filename) { |f| f.read }    # => "These words will remain intact"

	f = open(filename, "w") { |f| f << "Brevity is the soul of wit." }

	File.size(filename)                 # => 27

	File.truncate(filename, 30)

	File.size(filename)                 # => 30

	open(filename) { |f| f.read }

	# => "Brevity is the soul of wit.\000\000\000"

	require 'find'

	module Find

	  def match(*paths)

	    matched = []

	    find(*paths) { |path| matched << path if yield path }

	    return matched

	  end

	  module_function :match

	end

	Find.match("./") { |p| File.lstat(p).size == 0 }

	# => ["./Music/cancelled_download.MP3", "./tmp/empty2", "./tmp/empty1"]



	Find.match("./") { |p| ext = p[-4…p.size]; ext && ext.downcase == ".mp3" }

	# => ["./Music/The Snails - Red Rocket.mp3",

	# => "./Music/The Snails - Moonfall.mp3", "./Music/cancelled_download.MP3"]



	Find.match("./") { |p| File.split(p)[1] == "README" }

	# => ["./rubyprog-0.1/README", "./tmp/README"]

	Find.match("./") do |p|

	  Find.prune if p == "./tmp"

	  File.split(p)[1] == "README"

	end

	# => ["./rubyprog-0.1/README"]

	# Find all files that start with a particular phrase.

	must_start_with = "This Ruby program"

	Find.match("./") do |p|

	  if File.file? p

	    open(p) { |f| f.read(must_start_with.size) == must_start_with }

	  else

	    false

	  end

	end

	# => ["./rubyprog-0.1/README"]

 

Dir.getwd                     # => "/home/leonardr"

 

Dir.chdir("/bin")

	Dir.getwd          # => "/bin"

	File.exists? "ls"  # => true

	aBlock = { |x| puts x }                  # WRONG



	# SyntaxError: compile error

	aBlock = lambda { |x| puts x }           # RIGHT

	aBlock.call "Hello World!"

	# Hello World!

	def my_lambda(&aBlock)

	  aBlock

	end



	b = my_lambda { puts "Hello World My Way!" }

	b.call

	# Hello World My Way!

	b.class                                  # => Proc

	aBlock = Proc.new { |x| puts x }

	aBlock = proc { |x| puts x }

	aBlock = lambda { |x| puts x }

	add_lambda = lambda { |x,y| x + y }



	add_lambda.call(4)

	# ArgumentError: wrong number of arguments (1 for 2)



	add_lambda.call(4,5,6)

	# ArgumentError: wrong number of arguments (3 for 2)

	def call_twice

	  puts "I'm about to call your block." 

yield

	  puts "I'm about to call your block again."

	  yield

	end



	call_twice { puts "Hi, I'm a talking  

code block." }

	# I'm about to call your block.

	# Hi, I'm a talking code block.

	# I'm about to call your block again.

	# Hi, I'm a talking code block.

	def repeat(n)

	 if block_given?

	   n.times { yield }

	  else

	    raise ArgumentError.new("I can't repeat a block you don't give me!")

	  end

	end



	repeat(4) { puts "Hello." }

	# Hello.

	# Hello.

	# Hello.

	# Hello.



	repeat(4)

	# ArgumentError: I can't repeat a block you don't give me!

	puts("Print this message.") { puts "And also run this code block!" }

	# Print this message.

	def repeat(n)

	  n.times { yield } if block_given?

	end

	repeat(2) { puts "Hello." }

	# Hello.

	# Hello.

	def repeat(n, &block)

	  n.times { block.call } if block

	end

	repeat(2) { puts "Hello." }

	# Hello.

	# Hello.



	def repeat(n, &block)

	  n.times { yield } if block

	end

	repeat(2) { puts "Hello." }

	# Hello.

	# Hello.

	def biggest(collection, &block)

	  block ? collection.select(&block).max : collection.max

	end



	array = [1, 2, 3, 4, 5]

	biggest(array) {|i| i < 3}                  # => 2

	biggest(array) {|i| i != 5 }                   # => 4

	biggest(array)                                 # => 5

	def add_to_all(array, number)

	  array.collect { |x| x + number }

	end



	add_to_all([1, 2, 3], 10)              # => [11, 12, 13]

	tax_percent = 6

	position = lambda do

	  "I have always supported a #{tax_percent}% tax on imported limes."

	end

	position.call

	# => "I have always supported a 6% tax on imported limes."



	tax_percent = 7.25

	position.call

	# => "I have always supported a 7.25% tax on imported limes."

	counter = 0

	4.times { counter += 1; puts "Counter now #{counter}"}

	# Counter now 1

	# Counter now 2

	# Counter now 3

	# Counter now 4

	counter                                                # => 4

	accumulator = []

	[1, 2, 3].reverse_each { |x| accumulator << x + 1 }



	accumulator                  # => [4, 3, 2]

	class Tree

	  attr_reader :value

	  def initialize(value)

	    @value = value

	    @children = []

	  end



	  def <<(value)

	    subtree = Tree.new(value)

	    @children << subtree

	    return subtree

	  end

	end

	t = Tree.new("Parent")

	child1 = t << "Child 1"

	child1 << "Grandchild 1.1"

	child1 << "Grandchild 1.2"

	child2 = t << "Child 2"

	child2 << "Grandchild 2.1"

Figure 7-1: A simple tree

	class Tree

	  def each

	    yield value

	    @children.each do |child_node|

	      child_node.each { |e| yield e }

	    end

	  end

	end

	t.each { |x| puts x }

	# Parent

	# Child 1

	# Grandchild 1.1

	# Grandchild 1.2

	# Child 2

	# Grandchild 2.1

	array = %w{bob loves alice}

	array.collect { |x| x.capitalize }

	# => ["Bob", "Loves", "Alice"]

	array.collect_reverse { |x| x.capitalize }

	# => ["Alice", "Loves", "Bob"]

	require 'enumerator'

	reversed_array = array.to_enum(:reverse_each)

	reversed_array.collect { |x| x.capitalize }

	# => ["Alice", "Loves", "Bob"]



	reversed_array.each_with_index do |x, i|

	  puts %{#{i}=>"#{x}"}

	end

	# 0=>"alice"

	# 1=>"loves"

	# 2=>"bob"

	reversed_array[0]

	# NoMethodError: undefined method '[]' for #<Enumerable::Enumerator:0xb7c2cc8c>

	module Enumerable

	  def find_no_more_than(limit)

	    inject([]) do |a,e|

	      a << e if yield e

	      return a if a.size >= limit

	      a

	    end

	  end

	end

	a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

	a.find_no_more_than(3) { |x| x % 2 == 0 }         # => [2, 4, 6]

	1.upto(10) do |x|

	  puts x

	  break if x == 3

	end

	# 1

	# 2

	# 3

	aBlock = Proc.new do |x|

	  puts x

	  break if x == 3

	  puts x + 2

	end



	aBlock.call(5)

	# 5

	# 7



	aBlock.call(3)

	# 3

	# LocalJumpError: break from proc-closure

	require 'generator'



	enumerator = SyncEnumerator.new(%w{Four seven}, %w{score years},

	                                %w{and ago})

	enumerator.each do |row|

	  row.each { |word| puts word }

	  puts '---'

	end

	# Four

	# score

	# and

	# ---

	# seven

	# years

	# ago

	# ---



	enumerator = SyncEnumerator.new(%w{Four and}, %w{score seven years ago})

	enumerator.each do |row|

	  row.each { |word| puts word }

	  puts '---'

	end

	# Four

	# score

	# ---

	# and

	# seven

	# ---

	# nil

	# years

	# ---

	# nil

	# ago

	# ---

	def interosculate(*enumerables) 

generators = enumerables.collect { |x|  

Generator.new(x) }

	  done = false

	  until done

	    done = true

	    generators.each do |g|

	      if g.next?

	        yield g.next

	        done = false

	      end

	    end

	  end

	end



	interosculate(%w{Four and}, %w{score seven years ago}) do |x|

	  puts x

	end

	# Four

	# score

	# and

	# seven

	# years

	# ago

	def between_setup_and_cleanup

	  setup

	  begin

	   yield

	  finally

	    cleanup

	  end

	end

	def write_html(out, doctype=nil)

	  doctype ||= %{<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

	           "http://www.w3.org/TR/html4/loose.dtd">}

	  out.puts doctype

	  out.puts '<html>'

	  begin

	    yield out

	  ensure

	    out.puts '</html>'

	  end

	end



	write_html($stdout) do |out|

	  out.puts '<h1>Sorry, the Web is closed.</h1>'

	end

	# <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

	#      "http://www.w3.org/TR/html4/loose.dtd">

	# <html>

	# <h1>Sorry, the Web is closed.</h1>

	# </html>

	open('output.txt', 'w') do |out|

	  out.puts 'Sorry, the filesystem is also closed.'

	end

	module EventDispatcher

	  def setup_ 

listeners

	    @event_dispatcher_listeners = {}

	  end



	  def subscribe(event, &callback)

	    (@event_dispatcher_listeners[event] ||= []) << callback

	  end



	  protected

	  def notify(event, *args)

	    if @event_dispatcher_listeners[event]

	      @event_dispatcher_listeners[event].each do |m|

	        m.call(*args) if m.respond_to? :call

	      end

	    end

	    return nil

	  end

	end

	class Factory

	  include EventDispatcher



	def initialize

	  setup_listeners

	end



	def produce_widget(color)

	  #Widget creation code goes here…

	    notify(:new_widget, color)

	  end

	end

	class WidgetCounter

	  def initialize(factory)

	    @counts = Hash.new(0)

	    factory.subscribe(:new_widget) do |color|

	      @counts[color] += 1

	      puts "#{@counts[color]} #{color} widget(s) created since I started watching."

	    end

	  end

	end

	class Frog

	  def initialize(name)

	    @name = name

	  end



	  def speak

	    # It's a well-known fact that only frogs with long names start out

	    # speaking English.

	    @speaks_english ||= @name.size > 6

	    @speaks_english ? "Hi. I'm #{@name}, the talking frog." : 'Ribbit.'

	  end

	end



	Frog.new('Leonard').speak       # => "Hi. I'm Leonard, the talking frog."



	lucas = Frog.new('Lucas')

	lucas.speak                     # => "Ribbit."

	lucas.name

	# NoMethodError: undefined method 'name' for #<Frog:0xb7d0327c @speaks_english=true,

	@name="Lucas">



	class Frog 

attr_reader :name

	end

	lucas.name                      # => "Lucas"

	lucas.speaks_english = false

	# => NoMethodError: undefined method 'speaks_english=' for #<Frog:0xb7d0327c @speaks_

	#    english=false, @name="Lucas">



	class Frog 

attr_accessor :speaks_english

	end

	lucas.speaks_english = true

	lucas.speak                  # => "Hi. I'm Lucas, the talking frog."

	class Frog

	  def speaks_english

	    @speaks_english

	  end



	  def speaks_english=(value)

	    @speaks_english = value

	  end

	end

	class Warning

	  @@translations = { :en => 'Wet Floor',

	                     :es => 'Piso Mojado' }



	  def initialize(language=:en)

	    @language = language

	  end



	  def warn

	    @@translations[@language]

	  end

	end



	Warning.new.warn                             # => "Wet Floor"

	Warning.new(:es).warn                        # => "Piso Mojado"

	class Fate

	  NAMES = ['Klotho', 'Atropos', 'Lachesis'].freeze

	  @@number_instantiated = 0



	  def initialize

	    if @@number_instantiated >= NAMES.size

	      raise ArgumentError, 'Sorry, there are only three Fates.'

	    end

	    @name = NAMES[@@number_instantiated]

	    @@number_instantiated += 1

	    puts "I give you… #{@name}!"

	  end

	end



	Fate.new

	# I give you… Klotho!

	# => #<Fate:0xb7d2c348 @name="Klotho">



	Fate.new

	# I give you… Atropos!

	# => #<Fate:0xb7d28400 @name="Atropos">



	Fate.new

	# I give you… Lachesis!

	# => #<Fate:0xb7d22168 @name="Lachesis">



	Fate.new

	# ArgumentError: Sorry, there are only three Fates.

	def send_as_package(obj)

	  if obj.respond_to? :package

	    packaged = obj.package



	  else

	    $stderr.puts "Not sure how to package a #{obj.class}."

	    $stderr.puts 'Trying generic packager.'

	    package = Package.new(obj)

	  end

	  send(package)

	end

	def multiply_precisely(a, b)

	  if a.is_a? Float or b.is_a? Float



	    raise ArgumentError, "I can't do precise multiplication with floats."

	  end

	  a * b

	end



	multiply_precisely(4, 5) # => 20

	multiply_precisely(4.0, 5)

	# ArgumentError: I can't do precise multiplication with floats.

	def append_to_self(x)

	  unless x.respond_to? :<<

	    raise ArgumentError, "This object doesn't support the left-shift operator."

	  end

	  if x.is_a? Numeric

	    raise ArgumentError,

	    "The left-shift operator for this object doesn't do an append."

	  end

	  x << x

	end



	append_to_self('abc')                             # => "abcabc"

	append_to_self([1, 2, 3])                         # => [1, 2, 3, […]]



	append_to_self({1 => 2})

	# ArgumentError: This object doesn't support the left-shift operator.



	append_to_self(5)

	# ArgumentError: The left-shift operator for this object doesn't do an append.

	5 << 5                                      # => 160

	# That is, 5 * (2 ** 5)

	class String

	  def 

scramble

	    split(//).sort_by { rand }.join

	  end

	end



	"I once was a normal string.".scramble

	# => "i arg cn lnws.Ioateosma n r"

	class UnpredictableString < String

	  def scramble

	    split (//).sort_by { rand }.join

	  end



	  def inspect

	    scramble.inspect

	  end

	end

	str = UnpredictableString.new("It was a dark and stormy night.")

	# => " hsar gsIo atr tkd naaniwdt.ym"

	str

	# => "ts dtnwIktsr oydnhgi .mara aa"

	# The Rectangle constructor accepts arguments in either of the following forms:

	#  Rectangle.new([x_top, y_left], length, width)

	#  Rectangle.new([x_top, y_left], [x_bottom, y_right])

	class Rectangle

	  def 

initialize(*args)

	    case args.size

	    when 2

	      @top_left, @bottom_right = args

	    when 3

	      @top_left, length, width = args

	      @bottom_right = [@top_left[0] + length, @top_left[1] - width]

	    else

	      raise ArgumentError, "This method takes either 2 or 3 arguments."

	    end



	    # Perform additional type/error checking on @top_left and

	    # @bottom_right…

	  end

	end

	'

	Rectangle.new([10, 23], [14, 13])

	# => #<Rectangle:0xb7d15828 @bottom_right=[14, 13], @top_left=[10, 23]>



	Rectangle.new([10, 23], 4, 10)

	# => #<Rectangle:0xb7d0da4c @bottom_right=[14, 13], @top_left=[10, 23]>



	Rectangle.new

	# => ArgumentError: This method takes either 2 or 3 arguments.

	class Name



	  # Define default getter methods, but not 

setter methods.

	  attr_reader :first, :last



	  # When someone tries to set a first name, enforce rules about it.

	  def first=(first)

	    if first == nil or first.size == 0

	      raise ArgumentError.new('Everyone must have a first name.')

	    end

	    first = first.dup

	    first[0] = first[0].chr.capitalize

	    @first = first

	  end

	  # When someone tries to set a last name, enforce rules about it.

	  def last=(last)

	    if last == nil or last.size == 0

	      raise ArgumentError.new('Everyone must have a last name.')

	    end

	    @last = last

	  end



	  def full_name

	    "#{@first} #{@last}"

	  end

	

	  # Delegate to the setter methods instead of setting the instance

	  # variables directly.

	  def initialize(first, last)

	    self.first = first

	    self.last = last

	  end

	end

	class Arc

	  attr_accessor :radians



	  def degrees

	    @radians * 180 / Math::PI

	  end



	  def degrees=(degrees)

	    @radians = degrees * Math::PI / 180

	  end

	end



	arc = Arc.new

	arc.degrees = 180

	arc.radians                                # => 3.14159265358979

	arc.radians = Math::PI / 2

	arc.degrees                                # => 90.0

	require 'delegate'



	# An integer represented as an ordinal number (1st, 2nd, 3rd…), as

	# opposed to an ordinal number (1, 2, 3…) Generated by the

	# DelegateClass to have all the methods of the Fixnum class.

	class OrdinalNumber < DelegateClass(Fixnum)

	  def to_s

	    delegate_s = __getobj_ _.to_s

	    check = abs

	    if to_check == 11 or to_check == 12

	      suffix = "th"

	    else

	      case check % 10

	        when 1 then suffix = "st"

	        when 2 then suffix = "nd"

	        else suffix = "th"

	      end

	    end

	    return delegate_s + suffix

	  end

	end



	4.to_s # => "4"

	OrdinalNumber.new(4).to_s                    # => "4th"



	OrdinalNumber.new(102).to_s                  # => "102nd"

	OrdinalNumber.new(11).to_s                   # => "11th"

	OrdinalNumber.new(-21).to_s                  # => "-21st"



	OrdinalNumber.new(5).succ                    # => 6

	OrdinalNumber.new(5) + 6                     # => 11

	OrdinalNumber.new(5) + OrdinalNumber.new(6)  # => 11

	"4".to_i                                              # => 4

	4.to_s                                                # => "4"

	Time.now.to_f                                         # => 1143572140.90932

	{ "key1" => "value1", "key2" => "value2" }.to_a

	# => [["key1", "value1"], ["key2", "value2"]]

	def print_each(array)

	  array.each { |x| puts x.inspect }

	end



	hash = { "pickled peppers" => "peck of",

	         "sick sheep"      => "sixth" }

	print_each(hash.to_a)

	# ["sick sheep", "sixth"]

	# ["pickled peppers", "peck of"]



	print_each(hash)

	# ["sick sheep", "sixth"]

	# ["pickled peppers", "peck of"]

	a = [1,2,3]

	puts a

	# 1

	# 2

	# 3



	puts a.to_s

	# 123



	puts a.inspect

	# [1, 2, 3]

	puts /foo/

	# (?-mix:foo)

	puts /foo/.inspect

	# /foo/

	f = File.open('foo', 'a')

	puts f

	# #<File:0xb7c31c30>

	puts f.inspect

	# #<File:foo>

	periodic_table = [{ :symbol => "H", :name => "hydrogen", :weight => 1.007 },

	                  { :symbol => "Rg", :name => "roentgenium", :weight => 272 }]

	puts periodic_table.inspect

	# [{:symbol=>"H", :name=>"hydrogen", :weight=>1.007},

	# {:symbol=>"Rg", :name=>"roentgenium", :weight=>272}]



	eval(periodic_table.inspect)[0]

	# => {:symbol=>"H", :name=>"hydrogen", :weight=>1.007}

	class Dog

	  def initialize(name, age)

	    @name = name

	    @age = age * 7 #Compensate for dog years

	  end

	end



	spot = Dog.new("Spot", 2.1)

	spot.inspect

	# => "#<Dog:0xb7c16bec @name="Spot", @age=14.7>"

	class Dog

	  def inspect

	    "<A Dog named #{@name} who's #{@age} in dog years.>"

	  end

	  def to_s

	    inspect

	  end

	end

	spot.inspect

	# => "<A Dog named Spot who's 14.7 in dog years.>"

	class Dog

	  def inspect

	    %{Dog.new("#{@name}", #{@age/7})}

	  end

	end

	spot.inspect

	# => "Dog.new("Spot", 2.1)"

	eval(spot.inspect).inspect

	# => "Dog.new("Spot", 2.1)"

	def sum(*numbers)

	  puts "I'm about to sum the array #{numbers.inspect}"

	  numbers.inject(0) { |sum, x| sum += x }

	end



	sum(1, 2, 10)

	# I'm about to sum the array [1, 2, 10]

	# => 13



	sum(2, -2, 2, -2, 2, -2, 2, -2, 2)

	# I'm about to sum the array [2, -2, 2, -2, 2, -2, 2, -2, 2]

	# => 2

	

	sum

	# I'm about to sum the array []

	# => 0

	to_sum = []

	1.upto(10) { |x| to_sum << x }

	sum(*to_sum)

	# I'm about to sum the array [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

	# => 55

	sum(to_sum)

	# I'm about to sum the array [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]

	# TypeError: Array can't be coerced into Fixnum

	printf('%s | %s', 'left', 'right')

	# left | right

	inputs = ['left', 'right']

	printf('%s | %s', *inputs)

	# left | right

	def fun_with_text(text, args={})

	  text = text.upcase if args[:upcase]

	  text = text.downcase if args[:downcase]

	  if args[:find] and args[:replace]

	    text = text.gsub(args[:find], args[:replace])

	  end

	  text = text.slice(0, args[:truncate_at]) if args[:truncate_at]

	  return text

	end

	fun_with_text("Foobar", {:upcase => true, :truncate_at => 5})

	# => "FOOBA"

	fun_with_text("Foobar", :upcase => true, :truncate_at => 5)

	# => "FOOBA"

	fun_with_text("Foobar", :find => /(o+)/, :replace => '\1d', :downcase => true)

	# => "foodbar"

	###

	# This mix-in module lets methods match a caller's hash of keyword

	# parameters against a hash the method keeps, mapping keyword

	# arguments to default parameter values.

	#

	# If the caller leaves out a keyword parameter whose default value is

	# :MANDATORY (a constant in this module), then an error is raised.

	#

	# If the caller provides keyword parameters which have no

	# corresponding keyword arguments, an error is raised.

	#

	module KeywordProcessor

	  MANDATORY = :MANDATORY



	  def process_params(params, defaults)

	    # Reject params not present in defaults.

	    params.keys.each do |key|

	      unless defaults.has_key? key

	        raise ArgumentError, "No such keyword argument: #{key}"

	      end

	    end

	    result = defaults.dup.update(params)



	    # Ensure mandatory params are given.

	    unfilled = result.select { |k,v| v == MANDATORY }.map { |k,v| k.inspect }

	    unless unfilled.empty?

	      msg = "Mandatory keyword parameter(s) not given: #{unfilled.join(', ')}"

	      raise ArgumentError, msg

	    end



	    return result

	  end

	end

	class Recipe

	  # … The rest of the Recipe implementation goes here.

	  def cook(stove, cooking_time)

	    dish = prepare_ingredients

	    stove << dish

	    wait_for(cooking_time)

	    return dish

	  end

	end

	class RecipeWithExtraGarlic < Recipe

	  def cook(stove, cooking_time)



	    5.times { add_ingredient(Garlic.new.chop) }

	    super

	  end

	end

	class BakingRecipe < Recipe

	  def cook(cooking_time, oven_temperature=350)

	    oven = Oven.new(oven_temperature)

	    super(oven, cooking_time)

	  end

	end

	class Shape2D

	  def area

	    raise NotImplementedError.

	    new("#{self.class.name}#area is an 

abstract method.")

	  end

	end



	Shape2D.new.area

	# NotImplementedError: Shape2D#area is an  

abstract method.

	class Square < Shape2D

	  def initialize(length)

	    @length = length

	  end



	  def area

	    @length ** 2

	  end

	end



	Square.new(10).area 	                     # => 100

	class Shape2D

	  def initialize

	   raise NotImplementedError.

	    new("#{self.class.name} is an abstract class.")

	  end

	end



	Shape2D.new

	# NotImplementedError: Shape2D is an abstract class.

	class Class

	  def 

abstract(*args)

	    args.each do |method_name|

	

	      define_method(method_name) do |*args|

	        if method_name == :initialize

	          msg = "#{self.class.name} is an abstract class."

	        else

	          msg = "#{self.class.name}##{method_name} is an abstract method."

	        end

	        raise NotImplementedError.new(msg)



	     end

	    end

	  end

	end

	frozen_string = 'Brrrr!'

	frozen_string.freeze

	frozen_string.gsub('r', 'a')                     # => "Baaaa!"

	frozen_string.gsub!('r', 'a')

	# TypeError: can't modify frozen string

	sequences = [[1,2,3], [1,2,4], [1,4,9]].freeze

	sequences << [2,3,5]

	# TypeError: can't modify frozen array

	sequences[2] << 16                         # => [1, 4, 9, 16]

	frozen_string.clone.frozen?                      # => true

	frozen_string.dup.frozen?                        # => false

	frozen_string = 'A new string.'

	frozen_string.frozen?                            # => false

	API_KEY = "100f7vo4gg".freeze



	API_KEY[0] = 4

	# TypeError: can't modify frozen string



	API_KEY = "400f7vo4gg"

	# warning: already initialized constant API_KEY

	s1 = 'foo'                             # => "foo"

	s2 = s1.clone                          # => "foo"

	s1[0] = 'b'

	[s1, s2]                               # => ["boo", "foo"]

	material = 'cotton'

	class << material

	  def definition

	     puts 'The better half of velour.'

	  end

	end

	

	material.definition

	# The better half of velour.



	'cotton'.definition

	# NoMethodError: undefined method 'definition' for "cotton":String



	material.clone.definition

	# The better half of velour.



	material.dup.definition

	# NoMethodError: undefined method 'definition' for "cotton":String

	not_a_constant = 3

	not_a_constant = 10



	A_CONSTANT = 3

	A_CONSTANT = 10

	# warning: already initialized constant A_CONSTANT

	CONST = 4



	module ConstModule

	  CONST = 6

	end



	class ConstHolder

	  CONST = 8



	  def my_const

	    return CONST

	  end

	end



	CONST                                  # => 4

	ConstModule::CONST                     # => 6

	ConstHolder::CONST                     # => 8

	ConstHolder.new.my_const               # => 8

	E = 2.718281828                        # => 2.718281828

	E = 6                                  # warning: already initialized constant E

	E                                      # => 6

	class Regexp

	  def Regexp.is_valid?(str)

	    begin

	      compile(str)

	      valid = true

	    rescue RegexpError

	      valid = false

	    end

	  end

	end

	Regexp.is_valid? "The horror!"             # => true

	Regexp.is_valid? "The)horror!"             # => false

	def Fixnum.random(min, max)

	  raise ArgumentError, "min > max" if min > max

	  return min + rand(max-min+1)

	end

	Fixnum.random(10, 20)                                  # => 13

	Fixnum.random(-5, 0)                                   # => -5

	Fixnum.random(10, 10)                                  # => 10

	Fixnum.random(20, 10)

	# ArgumentError: min > max

	company_name = 'Homegrown Software'

	def company_name.legalese

	  return "#{self} is a registered trademark of ConglomCo International."

	end



	company_name.legalese

	# => "Homegrown Software is a registered trademark of ConglomCo International."

	'Some Other Company'.legalese

	# NoMethodError: undefined method 'legalese' for "Some Other Company":String

	class SecretNumber

	  def initialize

	    @secret = rand(20)

	  end

	  def hint

	    puts "The number is #{"not " if secret <= 10}greater than 10."

	  end 

private

	  def secret

	    @secret

	  end

	end



	s = SecretNumber.new

	s.secret

	# NoMethodError:  

private method 'secret' called for

	# #<SecretNumber:0xb7c2e83c @secret=19>



	s.hint

	# The number is greater than 10.

	class LessSecretNumber < SecretNumber

	  def hint

	    lower = secret-rand(10)-1

	    upper = secret+rand(10)+1

	    "The number is somewhere between #{lower} and #{upper}."

	  end

	end



	ls = LessSecretNumber.new

	ls.hint

	# => "The number is somewhere between -3 and 16."

	ls.hint

	# => "The number is somewhere between -1 and 15."

	ls.hint

	# => "The number is somewhere between -2 and 16."

	require 'set' # Deals with a collection of unordered values with no duplicates



	# Include this module to make your class taggable. The names of the

	# instance variable and the setup method are prefixed with "taggable_"

	# to reduce the risk of namespace collision. You must call

	# taggable_setup before you can use any of this module's methods.

	module Taggable

	  attr_accessor :tags



	  def taggable_setup

	    @tags = Set.new

	  end



	  def add_tag(tag)

	    @tags << tag

	  end



	  def remove_tag(tag)

	    @tags.delete(tag)

	  end

	end

	class TaggableString < String

	  include Taggable

	  def initialize(*args)

	    super

	    taggable_setup

	  end

	end

	s = TaggableString.new('It was the best of times, it was the worst of times.')

	s.add_tag 'dickens'

	s.add_tag 'quotation'

	s.tags # =>                       #<Set: {"dickens", "quotation"}>

	class Person

	  attr_reader :name, :age, :occupation



	   def initialize(name, age, occupation)

	     @name, @age, @occupation = name, age, occupation

	   end



	   def mild_mannered?

	     true

	   end

	end

	jimmy = Person.new('Jimmy Olsen', 21, 'cub reporter')

	clark = Person.new('Clark Kent', 35, 'reporter')

	jimmy.mild_mannered?                        # => true 

	clark.mild_mannered?                        # => true

	module SuperPowers

	  def fly

	    'Flying!'

	  end



	  def leap(what)

	     "Leaping #{what} in a single bound!"

	  end



	  def mild_mannered?

	     false

	  end



	  def superhero_name

	    'Superman'

	  end

	end

	clark.extend(SuperPowers)

	clark.superhero_name                   # => "Superman"

	clark.fly                              # => "Flying!"

	clark.mild_mannered?                   # => false

	jimmy.mild_mannered?                   # => true

	class Person 

	  extend SuperPowers 

	end



	#which is equivalent to:

	Person.extend(SuperPowers)

	module MyLib

	  module ClassMethods

	    def class_method

	      puts "This method was first defined in MyLib::ClassMethods"

	    end

	  end

	end

	module MyLib

	  def self.included(receiver)

	    puts "MyLib is being included in #{receiver}!"

	    receiver.extend(ClassMethods)

	  end

	end

	class MyClass

	  include MyLib

	end

	# MyLib is being included in MyClass!



	MyClass.class_method

	# This method was first defined in MyLib::ClassMethods

	class MultiArray

	  include Enumerable



	  def initialize(*arrays)

	    @arrays = arrays

	  end



	  def each

	    @arrays.each { |a| a.each { |x| yield x } }

	  end

	end



	ma = MultiArray.new([1, 2], [3], [4])

	ma.collect                                        # => [1, 2, 3, 4]

	ma.detect { |x| x > 3 }                        # => 4

	ma.map { |x| x ** 2 }                             # => [1, 4, 9, 16]

	ma.each_with_index { |x, i| puts "Element #{i} is #{x}" }

	# Element 0 is 1

	# Element 1 is 2

	# Element 2 is 3

	# Element 3 is 4

	Enumerable.instance_methods.sort

	# => ["all?", "any?", "collect", "detect", "each_with_index", "entries",

	# => "find", "find_all", "grep", "include?", "inject", "map", "max",

	# => "member?", "min", "partition", "reject", "select", "sort", "sort_by",

	# => "to_a", "zip"]

	module StringTheory

	  class String

	    def initialize(length=10**-33)

	      @length = length

	    end

	  end

	end



	String.new                                    # => ""



	StringTheory::String.new

	# => #<StringTheory::String:0xb7c343b8 @length=1.0e-33>

	# functions.rb

	module Decidable

	  # … Many, many methods go here.

	end



	module Semidecidable

	  # … Many, many methods go here.

	end

	# functions.rb

	autoload :Decidable, "decidable.rb"

	autoload :Semidecidable, "semidecidable.rb"

	# decidable.rb

	module Decidable

	  # … Many, many methods go here.

	end

	# semidecidable.rb

	module Semidecidable

	  # … Many, many methods go here.

	end

	require 'functions'

	Decidable.class                                           # => Module

	# More use of the Decidable module follows…

	require 'rexml/document'



	REXML::Document.new(xml)

	require 'rexml/document'

	include REXML



	Document.new(xml)

	require 'rexml/parsers/pullparser'



	REXML::Parsers::PullParser.new("Some XML")

	require 'rexml/parsers/pullparser'

	include REXML::Parsers



	PullParser.new("Some XML")

	module Timeable

	 attr_reader :time_created



	 def initialize

	   @time_created = Time.now

	 end



	 def age #in seconds

	   Time.now - @time_created

	 end

	end

	class Character

	  include Timeable

	  attr_reader :name

	  def initialize( name )

	    @name = name

	    super() #calls Timeable's initialize

	  end

	end

	c = Character.new "Fred"



	c.time_created

	# => Mon Mar 27 18:34:31 EST 2006

	Character.ancestors                    # => [Character, Timeable, Object, Kernel]

	class Class

	  def included_modules

	    @included_modules ||= []

	  end



	  alias_method :old_new, :new

	  def new(*args, &block)

	    obj = old_new(*args, &block)

	    self.included_modules.each do |mod|

	      mod.initialize if mod.respond_to?(:initialize)

	    end

	    obj

	  end

	end

	module Initializable



	  def self.included(mod)

	    mod.extend ClassMethods

	  end



	  module ClassMethods

	    def included(mod)

	      if mod.class != Module #in case Initializeable is mixed-into a class 

	        puts "Adding #{self} to #{mod}'s included_modules" if $DEBUG 

	        mod.included_modules << self

	      end

	    end

	  end

	end

	'a string'.class                                   # => String

	'a string'.class.name                              # => "String"

	'a string'.class.superclass                        # => Object

	String.superclass                                  # => Object

	String.class                                       # => Class

	String.class.superclass                            # => Module

	'a string'.class.new                               # => ""

	class Class

	  def hierarchy

	    (superclass ? superclass.hierarchy : []) << self

	  end

	end

	Array.hierarchy                                     # => [Object, Array]



	class MyArray < Array

	end

	MyArray.hierarchy                                   # => [Object, Array, MyArray]

	String.superclass                 # => Object

	String.ancestors                  # => [String, Enumerable, Comparable, Object, Kernel]

	Array.ancestors                   # => [Array, Enumerable, Object, Kernel]

	MyArray.ancestors                 # => [MyArray, Array, Enumerable, Object, Kernel]



	Object.ancestors                  # => [Object, Kernel]



	class MyClass

	end

	MyClass.ancestors                 # => [MyClass, Object, Kernel]

	Object.methods

	# => ["name", "private_class_method", "object_id", "new",

	# "singleton_methods", "method_defined?", "equal?", … ]

	Object.singleton_methods    # => []

	Fixnum.singleton_methods    # => ["induced_from"]



	class MyClass

	  def MyClass.my_singleton_method

	  end



	  def my_instance_method

	  end

	end

	MyClass.singleton_methods    # => ["my_singleton_method"]

	''.methods == String.instance_methods         # => true

	Object.methods.sort

	# => ["<", "<=", "<=>", "==", "===", "=~", ">", ">=",

	# "__id__", "__send__", "allocate", "ancestors", … ]

	MyClass.method_defined? :my_instance_method     # => true

	MyClass.new.respond_to? :my_instance_method     # => true

	MyClass.respond_to? :my_instance_method         # => false



	MyClass.respond_to? :my_singleton_method        # => true

	class Object

	  def 

my_methods_only

	    my_super = self.class.superclass

	    return my_super ? methods - my_super.instance_methods : methods

	  end

	end



	s = ''

	s.methods.size                             # => 143

	Object.instance_methods.size               # =>  41

	s.my_methods_only.size                     # => 102

	(s.methods - Object.instance_methods).size # => 102



	def s.singleton_method( )

	end

	s.methods.size                             # => 144

	s.my_methods_only.size                     # => 103



	class Object

	  def new_object_method

	  end

	end

	s.methods.size                             # => 145

	s.my_methods_only.size                     # => 103



	class MyString < String

	  def my_string_method

	  end

	end

	MyString.new.my_methods_only               # => ["my_string_method"]

	class Object

	  def my_methods_only_no_mixins

	  self.class.ancestors.inject(methods) do |mlist, ancestor|

	    mlist = mlist - ancestor.instance_methods unless ancestor.is_a? Class

	    mlist

	  end

	end



	[].methods.size                                 # => 121

	[].my_methods_only.size                         # => 78

	[].my_methods_only_no_mixins.size               # => 57

	s = 'A string'

	length_method = s.method(:length) # => #<Method: String#length>

	length_method.arity               # => 0

	length_method.call                # => 8

	1.succ                            # => 2

	1.method(:succ).call              # => 2

	5.method('+').call(10)            # => 15



	[1,2,3].method(:each).call { |x| puts x }

	# 1

	# 2

	# 3

	class EventSpawner



	  def initialize

	    @listeners = []

	    @state = 0

	  end



	  def subscribe(&listener)

	    @listeners << listener

	  end



	  def change_state(new_state)

	    @listeners.each { |l| l.call(@state, new_state) }

	    @state = new_state

	  end

	end



	class EventListener

	  def hear(old_state, new_state)

	    puts "Method triggered: state changed from #{old_state} " +

	      "to #{new_state}."

	  end

	end



	spawner = EventSpawner.new

	spawner.subscribe do |old_state, new_state|

	 puts "Block triggered: state changed from #{old_state} to #{new_state}."

	end



	spawner.subscribe &EventListener.new.method(:hear)

	spawner.change_state(4)

	# Block triggered: state changed from 0 to 4.

	# Method triggered: state changed from 0 to 4.

	class Multiplier

	  def double_your_pleasure(pleasure)

	    return pleasure * 3 # FIXME: Actually triples your pleasure.

	  end

	end



	m = Multiplier.new

	m.double_your_pleasure(6)                              # => 18

	class Multiplier

	  alias :double_your_pleasure_BUGGY :double_your_pleasure

	  def double_your_pleasure(pleasure)

	    return pleasure * 2

	  end

	end

	m.double_your_pleasure(6)                              # => 12



	m.double_your_pleasure_BUGGY(6)                        # => 18

	class Tracker

	  def important

	    "This is an important method!"

	  end



	  def self.method_added(sym)

	    if sym == :important

	      raise 'The "important" method has been redefined!'

	    else

	      puts %{Method "#{sym}" was (re)defined.}

	    end

	  end



	  def self.method_removed(sym)

	    if sym == :important

	      raise 'The "important" method has been removed!'

	    else

	      puts %{Method "#{sym}" was removed.}

	   end

	  end



	  def self.method_undefined(sym)

	    if sym == :important

	      raise 'The "important" method has been undefined!'

	    else

	      puts %{Method "#{sym}" was removed.}

	    end

	  end

	end

	class Tracker

	  def new_method

	    'This is a new method.'

	  end

	end

	# Method "new_method" was (re)defined.

	class Tracker

	  undef :important

	end

	# RuntimeError: The "important" method has been undefined!

	class Object

	  def must_have_instance_variables(*args)

	    vars = instance_variables.inject({}) { |h,var| h[var] = true; h }

	    args.each do |var|

	      unless vars[var]

	        raise ArgumentError, %{Instance variable "@#{var} not defined"}

	      end

	    end

	  end

	end

	module LightEmitting

	  def LightEmitting_setup

	    must_have_instance_variables :light_color, :light_intensity

	    @on = false

	  end



	  # Methods that use @light_color and @light_intensity follow…

	end

	class Request

	  def initialize

	    gather_parameters # This is a virtual method defined by subclasses

	    must_have_instance_variables :action, :user, :authentication

	  end



	  # Methods that use @action, @user, and @authentication follow…

	end

	class MyClass

	  def defined_method

	    'This method is defined.'

	  end



	  def method_missing(m, *args)

	    "Sorry, I don't know about any #{m} method."

	  end

	end



	o = MyClass.new

	o.defined_method                      # => "This method is defined."

	o.undefined_method

	# => "Sorry, I don't know about any undefined_method method."

	class Fixnum

	  def method_missing(m, *args)

	    if args.size > 0

	      raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)")

	    end

	    match = /^plus_([0-9]+)$/.match(m.to_s)

	    if match

	      self + match.captures[0].to_i

	    else

	      raise NoMethodError.

	    new(" 

undefined method '#{m}' for #{inspect}:#{self.class}")

	    end

	  end

	end



	4.plus_5                                         # => 9

	10.plus_0                                        # => 10

	-1.plus_2                                        # => 1

	100.plus_10000                                   # => 10100

	20.send(:plus_25)                                # => 45



	100.minus_3

	# NoMethodError:  

undefined method 'minus_3' for 100:Fixnum

	100.plus_5(105)

	# ArgumentError: wrong number of arguments (1 for 0)

	class RGBColor(red=0, green=0, blue=0)

	  @red = red

	  @green = green

	  @blue = blue

	end

	class Object

	  private

	  def set_instance_variables(binding, *variables)

	    variables.each do |var|

	      instance_variable_set("@#{var}", eval(var, binding))

	    end

	  end

	end

	class RGBColor

	  def initialize(red=0, green=0, blue=0)

	    set_instance_variables(binding, *local_variables)

	  end

	end



	RGBColor.new(10, 200, 300)

	# => #<RGBColor:0xb7c22fc8 @red=10, @blue=300, @green=200>

	class RGBColor

	  def initialize(red=0, green=0, blue=0, debug=false)

	    set_instance_variables(binding, *local_variables-['debug'])

	    puts "Color: #{red}/#{green}/#{blue}" if debug

	  end

	end



	RGBColor.new(10, 200, 255, true)

	# Color: 10/200/255

	# => #<RGBColor:0xb7d309fc @blue=255, @green=200, @red=10>

	class Fetcher

	  def fetch(how_many)

	    puts "Fetching #{how_many ? how_many : "all"}."

	  end

	  def fetch_one

	    fetch(1)

	  end



	  def fetch_ten

	   fetch(10)

	  end



	  def fetch_all

	    fetch(nil)

	  end

	end

	class GeneratedFetcher

	  def fetch(how_many)

	    puts "Fetching #{how_many ? how_many : "all"}."

	  end



	  [["one", 1], ["ten", 10], ["all", nil]].each do |name, number|

	    define_method("fetch_#{name}") do

	      fetch(number)

	    end

	  end

	end



	GeneratedFetcher.instance_methods - Object.instance_methods

	# => ["fetch_one", "fetch", "fetch_ten", "fetch_all"]



	GeneratedFetcher.new.fetch_one

	# Fetching 1.



	GeneratedFetcher.new.fetch_all

	# Fetching all.

	class Numeric

	 [['add', '+'], ['subtract', '-'],

	  ['multiply', '*',], ['divide', '/']].each do |method, operator|

	    define_method("#{method}_2") do

	      method(operator).call(2)

	    end

	  end

	end

	class Numeric

	  [['add', '+'], ['subtract', '-'],

	   ['multiply', '*',], ['divide', '/']].each do |method, operator|

	    module_eval %{ def #{method}_2

	                     self.#{operator}(2)

	                   end }

	  end

	end



	4.add_2                                                  # => 6

	10.divide_2                                              # => 5

	def broken_print_variable(var_name)

	  eval %{puts "The value of #{var_name} is " + #{var_name}.to_s}

	end

	tin_snips = 5



	broken_print_variable('tin_snips')

	# NameError: undefined local variable or method 'tin_snips' for main:Object



	var_name = 'tin_snips'

	eval %{puts "The value of #{var_name} is " + #{var_name}.to_s}

	# The value of tin_snips is 5

	def print_variable(var_name, binding)

	  eval %{puts "The value of #{var_name} is " + #{var_name}.to_s}, binding

	end



	vice_grips = 10

	print_variable('vice_grips', binding)

	# The value of vice_grips is 10

	class RandomizingArray < Array

	  def <<(e)

	    insert(rand(size), e)

	  end



	  def [](i)

	    super(rand(size))

	  end

	end



	a = RandomizingArray.new

	a << 1 << 2 << 3 << 4 << 5 << 6  # => [6, 3, 4, 5, 2, 1]



	# That was fun; now let's get some of those entries back.

	a[0]                                                                 # => 1

	a[0]                                                                 # => 2

	a[0]                                                                 # => 5

	#No, seriously, a[0].

	a[0]                                                                 # => 4

	#It's a madhouse! A madhouse!

	a[0]                                                                 # => 3

	#That does it!



	class RandomizingArray

	  remove_method('[]')

	end



	a[0]                                                                 # => 6

	a[0]                                                                 # => 6

	a[0]                                                                 # => 6



	# But the overridden << operator still works randomly:

	a << 7                                                         # => [6, 3, 4, 7, 5, 2, 1]

	class InventoryItem

	  attr_accessor :name, :unit_price



	  def initialize(name, unit_price)

	    @name, @unit_price = name, unit_price

	  end



	  def price(quantity=1)

	    @unit_price * quantity

	  end



	  #Make InventoryItem#cost an alias for InventoryItem#price

	  alias :cost :price

	

	  #The attr_accessor decorator created two methods called "unit_price" and

	  #"unit_price=". I'll create 

aliases for those methods as well.

	  alias :unit_cost :unit_price

	  alias :unit_cost= :unit_price=

	end



	bacon = InventoryItem.new("Chunky Bacon", 3.95)

	bacon.price(100)                                  # => 395.0

	bacon.cost(100)                                   # => 395.0



	bacon.unit_price                                  # => 3.95

	bacon.unit_cost                                   # => 3.95

	bacon.unit_cost = 3.99

	bacon.cost(100)                                   # => 399.0

	require 'aspectr'

	class Verbose < AspectR::Aspect



	 def describe(method_sym, object, *args)

	    "#{object.inspect}.#{method_sym}(#{args.join(",")})"

	  end



	  def before(method_sym, object, return_value, *args)

	    puts "About to call #{describe(method_sym, object, *args)}."

	  end



	  def after(method_sym, object, return_value, *args)

	    puts "#{describe(method_sym, object, *args)} has returned " +

	      return_value.inspect + '.'

	  end

	end

	verbose = Verbose.new

	stack = []

	verbose.wrap(stack, :before, :after, :push, :pop)



	stack.push(10)

	# About to call [].push(10).

	# [10].push(10) has returned [[10]].



	stack.push(4)

	# About to call [10].push(4).

	# [10, 4].push(4) has returned [[10, 4]].



	stack.pop

	# About to call [10, 4].pop().

	# [10].pop() has returned [4].

	module Contracts

	  def valid_contract(input)

	    if @user_defined and @user_defined[input]

	      @user_defined[input]

	    else

	      case input

	      when :number

	        lambda { |x| x.is_a? Numeric }

	      when :string

	        lambda { |x| x.respond_to? :to_str }

	      when :anything

	        lambda { |x| true }

	      else

	        lambda { |x| false }

	      end

	    end

	  end



	  class ContractViolation < StandardError

	  end



	  def define_data(inputs={}.freeze)

	    @user_defined ||= {}

	    inputs.each do |name, contract|

	      @user_defined[name] = contract if contract.respond_to? :call

	    end

	  end



	  def contract(method, *inputs)

	    @contracts ||= {}

	    @contracts[method] = inputs

	    method_added(method)

	  end



	  def setup_contract(method, inputs)

	    @contracts[method] = nil

	    method_renamed = "__#{method}".intern

	    conditions = ""

	    inputs.flatten.each_with_index do |input, i|

	      conditions << %{

	       if not self.class.valid_contract(#{input.inspect}).call(args[#{i}])

	          raise ContractViolation, "argument #{i+1} of method '#{method}' must" +

	                  "satisfy the '#{input}' contract", caller

	        end

	      }

	    end



	   class_eval %{

	       alias_method #{method_renamed.inspect}, #{method.inspect}

	       def #{method}(*args)

	         #{conditions}

	         return #{method_renamed}(*args)

	       end

	     }

	  end



	  def method_added(method)

	    inputs = @ 

contracts[method]

	    setup_contract(method, inputs) if inputs

	  end

	end

	class TestContracts

	  def hello(n, s, f)

	    n.times { f.write "hello #{s}!\n" }

	  end

	require 'rexml/document'

	def 

valid_xml?(xml)

	 begin

	   REXML::Document.new(xml)

	 rescue REXML::ParseException

	   # Return nil if an exception is thrown

	 end

	end

	bad_xml = %{

	<tasks>

	 <pending>

	   <entry>Grocery Shopping</entry>

	 <done>

	   <entry>Dry Cleaning</entry>

	</tasks>}



	valid_xml?(bad_xml)                           # => nil

	good_xml = %{

	<groceries>

	 <bread>Wheat</bread>

	 <bread>Quadrotriticale</bread>

	</groceries>}



	doc = valid_xml?(good_xml)

	doc.root.elements[1]                          # => <bread> … </>

	orders_xml = %{

	<orders>

	  <order>

	    <number>105</number>

	    <date>02/10/2006</date>

	    <customer>Corner Store</customer>

	    <items>

	      <item upc="404100" desc="Red Roses" qty="240" />

	      <item upc="412002" desc="Candy Hearts" qty="160" />

	    </items>

	  </order>

	</orders>}



	require 'rexml/document'

	orders = REXML::Document.new(orders_xml)

	orders.root.each_element do |order|    # each <order> in <orders>

	  order.each_element do |node|         # <customer>, <items>, etc. in <order>

	    if node.has_elements?

	      node.each_element do |child|     # each <item> in <items>

	        puts "#{child.name}: #{child.attributes['desc']}"

	      end

	    else

	      # the contents of <number>, <date>, etc.

	      puts "#{node.name}: #{node.text}"

	    end

	  end

	end

	# number: 105

	# date: 02/10/2006

	# customer: Corner Store

	# item: Red Roses

	# item: Candy Hearts

	event_xml = %{

	<events>

	  <clean system="dev" start="01:35" end="01:55" area="build" error="1" />

	  <backup system="prod" start="02:00" end="02:35" size="2300134" error="0" />

	  <backup system="dev" start="02:00" end="02:01" size="0" error="2" />

	  <backup system="test" start="02:00" end="02:47" size="327450" error="0" />

	</events>}

	require 'rexml/document'

	require 'rexml/streamlistener'



	class ErrorListener

	  include REXML::StreamListener

	  def tag_start(name, attrs)

	    if attrs["error"] != nil and attrs["error"] != "0"

	      puts %{Event "#{name}" failed for system "#{attrs["system"]}" } +

	    %{with code #{attrs["error"]}}

	    end

	  end

	end

	REXML::Document.parse_stream(event_xml, ErrorListener.new)

	# Event "clean" failed for system "dev" with code 1

	# Event "backup" failed for system "dev" with code 2

	xml = %{

	<aquarium>

	 <fish color="blue" size="small" />



	 <fish color="orange" size="large">

	   <fish color="green" size="small">

	    <fish color="red" size="tiny" />

	   </fish>

	 </fish>



	 <decoration type="castle" style="gaudy">

	   <algae color="green" />

	  </decoration>

	 </aquarium>}



	 require 'rexml/document'

	 doc = REXML::Document.new xml

Figure 11-1: The aquarium

	REXML::XPath.first(doc, '//fish')

	# => <fish size='small' color='blue'/>

	REXML::XPath.match(doc, '//[@color="green"]')

	# => [<fish size='small' color='green'> … </>, <algae color='green'/>]

	def describe(fish)

	  "#{fish.attribute('size')} #{fish.attribute('color')} fish"

	end

	REXML:: 

XPath.each(doc, '//fish/fish') do |fish|

	  puts "The #{describe(fish.parent)} has eaten the #{describe(fish)}."

	end

	# The large orange fish has eaten the small green fish.

	# The small green fish has eaten the tiny red fish.

	require 'rubygems'

	require 'rubyful_soup'



	invalid_html = 'A lot of <b class=1>tags are <i class=2>never closed.'

	soup = BeautifulSoup.new(invalid_html)

	puts soup.prettify

	# A lot of

	#  <b class="1">tags are

	#   <i class="2">never closed.

	#   </i>

	#  </b>



	soup.b.i                                       # => <i class="2">never closed.</i>

	soup.i                                         # => <i class="2">never closed.</i>

	soup.find(nil, :attrs=>{'class' => '2'}) # => <i class="2">never closed.</i>

	soup.find_all('i')                             # => [<i class="2">never closed.</i>]



	soup.b['class']                                # => "1"



	soup.find_text(/closed/)                       # => "never closed."

	xml = %{

	<freezer temp="-12" scale="celcius">

	 <food>Phyllo dough</food>

	 <food>Ice cream</food>

	 <icecubetray>

	  <cube1 />

	  <cube2 />

	 </icecubetray>

	</freezer>}

	require 'rubygems'

	require 'xmlsimple'



	doc = XmlSimple.xml_in xml

	require 'pp'

	pp doc

	# {"icecubetray"=>[{"cube2"=>[{}], "cube1"=>[{}]}],

	#  "food"=>["Phyllo dough", "Ice cream"],

	#  "scale"=>"celcius",

	#  "temp"=>"-12"}

	xml = %{

	<freezer temp="-12" scale="celcius">

	 <item name="Phyllo dough" type="food" />

	 <item name="Ice cream" type="food" />

	 <item name="Ice cube tray" type="container">

	  <item name="Ice cube" type="food" />

	  <item name="Ice cube" type="food" />

	 </item>

	</freezer>}

	parsed1 = XmlSimple.xml_in xml

	pp parsed1

	# {"scale"=>"celcius",

	#  "item"=>

	#   [{"name"=>"Phyllo dough", "type"=>"food"},

	#    {"name"=>"Ice cream", "type"=>"food"},

	# {"name"=>"Ice cube tray",

	#    "type"=>"container",

	#    "item"=>

	#    [

	require 'rubygems'

	require ' 

libxml'



	dtd = XML::Dtd.new(%{<!ELEMENT rubycookbook (recipe+)>

	<!ELEMENT recipe (title?, problem, solution, discussion, seealso?)+>

	<!ELEMENT title (#PCDATA)>

	<!ELEMENT problem (#PCDATA)>

	<!ELEMENT solution (#PCDATA)>

	<!ELEMENT discussion (#PCDATA)>

	<!ELEMENT seealso (#PCDATA)>})

	open('cookbook.xml', 'w') do |f|

	  f.write %{<?xml version="1.0"?>

	<rubycookbook>

	 <recipe>

	   <title>A recipe</title>

	   <problem>A difficult/common problem</problem>

	   <solution>A smart solution</solution>

	   <discussion>A deep solution</discussion>

	   <seealso>Pointers</seealso>

	 </recipe>

	</rubycookbook>

	}

	end

	document = XML::Document.file('cookbook.xml')

	document.validate(dtd)                           # => true

	schema = XML::Schema.from_string %{<?xml version="1.0"?>



	<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	  <xsd:element name="recipe" type="recipeType"/>



	  <xsd:element name="rubycookbook" type="rubycookbookType"/>

	  

	  <xsd:element name="title"      type="xsd:string"/>

	  <xsd:element name="problem"    type="xsd:string"/>

	  <xsd:element name="solution"   type="xsd:string"/>

	  <xsd:element name="discussion" type="xsd:string"/>

	  <xsd:element name="seealso"    type="xsd:string"/>



	  <xsd:complexType name="rubycookbookType">

	   <xsd:sequence>

	      <xsd:element ref="recipe"/>

	    </xsd:sequence>

	 </xsd:complexType>

	  <xsd:complexType name="recipeType">

	    <xsd:sequence>

	      <xsd:element ref="title"/>

	      <xsd:element ref="problem"/>

	      <xsd:element ref="solution"/>

	      <xsd:element ref="discussion"/>

	      <xsd:element ref="seealso"/>

	  </xsd:sequence>

	</xsd:complexType>



	</xsd:schema>

	}



	document.validate(schema)                         	# => true

	require 'rexml/document'



	str = %{<?xml version="1.0"?>

	<!DOCTYPE doc [

	  <!ENTITY product 'Stargaze'>

	  <!ENTITY version '2.3'>

	]>

	<doc>

	 &product; v&version; is the most advanced astronomy product on the market.

	</doc>}

	doc = REXML::Document.new str



	doc.root.children[0].value

	# => "\n Stargaze v2.3 is the most advanced astronomy product on the market.\n"

	doc.root.text

	# => "\n Stargaze v2.3 is the most advanced astronomy product on the market.\n"



	doc.root.children[0].to_s

	# => "\n &product; v&version; is the most advanced astronomy product on the market.\n"

	doc.root.write

	# <doc>

	# &product; v&version; is the most advanced astronomy program on the market.

	# </doc>

	require 'rexml/document'

	require

	doc = REXML::Document.new

	meeting = doc.add_element 'meeting'

	meeting_start = Time.local(2006, 10, 31, 13)

	meeting.add_element('time', { 'from' => meeting_start,

	                              'to' => meeting_start + 3600 })



	doc.children[0]                                 # => <meeting> … </>

	doc.children[0].children[0]

	# => "<time from='Tue Oct 31 13:00:00 EST 2006'

	#      to='Tue Oct 31 14:00:00 EST 2006'/>"



	doc.write($stdout, 1)

	# <meeting>

	#  <time from='Tue Oct 31 13:00:00 EST 2006'

	#        to='Tue Oct 31 14:00:00 EST 2006'/>

	# </meeting>

	doc.children[0]                                 # => <?xml … ?>

	doc.children[1]                                 # => <meeting> … </>

	agenda = meeting.add_element 'agenda'

	doc.children[1].children[1]               # => <agenda/>



	agenda. 

add_text "Nothing of importance will be decided."

	agenda.add_text " The same tired ideas will be rehashed yet again."



	doc.children[1].children[1]               # => <agenda> … </>



	doc.write($stdout, 1)

	# <meeting>

	#  <time from='Tue Oct 31 13:00:00 EST 2006'

	#         to='Tue Oct 31 14:00:00 EST 2006'/>

	#  <agenda>

	#   Nothing of importance will be decided. The same tired ideas will be

	#   rehashed yet again.

	#  </agenda>

	# </meeting>

	item1 = agenda.add_element 'item'

	doc.children[1].children[1].children[1]       # => <item/>

	item1.text = 'Weekly status meetings: improving attendance'

	doc.children[1].children[1].children[1]       # => <item> … </>

	doc.write($stdout, 1)

	# <meeting>

	#  <time from='Tue Oct 31 13:00:00 EST 2006'

	#        to='Tue Oct 31 14:00:00 EST 2006'/>

	#  <agenda>

	#   Nothing of importance will be decided. The same tired ideas will be

	#   rehashed yet again.

	#   <item>Weekly status meetings: improving attendance</item>

	#  </agenda>

	# </meeting>

	require 'rexml/document'



	text = %{<doc><a>Some whitespace</a> <b>Some more</b></doc>}



	REXML::Document.new(text, { :compress_whitespace => :all }).to_s

	# => "<doc><a>Some whitespace</a> <b>Some more</b></doc>"

	REXML::Document.new(text, { :compress_whitespace => %w{a} }).to_s

	# => "<doc><a>Some whitespace</a> <b>Some more</b></doc>"

	REXML::Document.new(text, { :respect_whitespace => %w{a} }).to_s

	# => "<doc><a>Some whitespace</a> <b>Some more</b></doc>"

	text = %{<doc><a>Some text</a>\n <b>Some more</b>\n\n}

	REXML::Document.new(text, { :compress_whitespace => :all }).to_s

	# => "<doc><a>Some text</a>\n <b>Some more</b>\n</doc>"

	REXML::Document.new(text, { :compress_ 

whitespace => :all,

	                        :ignore_ 

whitespace_nodes => :all }).to_s

	# => "<doc><a>Some text</a><b>Some more</b></doc>"

	doc = %{<?xml version="1.0"?>

	     <menu tipo="specialità" giorno="venerdì">

	    <primo_piatto>spaghetti al ragù</primo_piatto>

	        <bevanda>frappè</bevanda>

	     </menu>}

	require 'charguess'



	CharGuess::guess doc

	# => "windows-1252"

	<xml version="1.0" encoding="utf-8"?>

	CharGuess::guess("\xA4\xCF")               # => "EUC-JP"

	doc = %{<?xml version="1.0"?>

	     <menu tipo="specialità" giorno="venerdì">

	    <primo_piatto>spaghetti al ragù</primo_piatto>

	       <bevanda>frappè</bevanda>

	     </menu>}

	require 'iconv'

	require 'charguess' # not necessary if input encoding is known



	input_encoding = CharGuess::guess doc                 # => "windows-1252"

	output_encoding = 'utf-8'



	converted_doc = Iconv.new(output_encoding, input_encoding).iconv(doc)



	CharGuess::guess(converted_doc) 	                  # => "UTF-8"

	require 'uri'



	text = %{"My homepage is at

	<a href="http://www.example.com/">http://www.example.com/</a>, and be sure

	to check out my weblog at http://www.example.com/blog/. Email me at <a

	href="mailto:bob@example.com">bob@example.com</a>.} 

URI.extract(text)

	# => ["http://www.example.com/", "http://www.example.com/",

	#        "http://www.example.com/blog/.", "mailto:bob@example.com"]



	# Get HTTP(S) links only.

	URI.extract(text, ['http', 'https'])

	# => ["http://www.example.com/", "http://www.example.com/"

	#        "http://www.example.com/blog/."]

	require 'rexml/document'

	require 'rexml/streamlistener'

	require 'set'



	class LinkGrabber

	  include REXML::StreamListener

	  attr_reader :links



	def initialize(interesting_tags = {'a' => %w{href}, 'img' => %w{src}}.freeze)

	   @tags = interesting_tags

	   @links = Set.new

	 end

	  def tag_start(name, attrs)

	    @tags[name].each do |uri_attr|

	      @links << attrs[uri_attr] if attrs[uri_attr]

	    end if @tags[name]

	  end



	  def parse(text)

	    REXML::Document.parse_stream(text, self)

	  end

	end



	grabber = 

LinkGrabber.new

	grabber.parse(text)

	grabber.links

	# => #<Set: {"http://www.example.com/", "mailto:bob@example.com"}>

	require 'rubygems'

	require 'redcloth'



	text = RedCloth.new %{Who would ever write "HTML":http://www.w3.org/MarkUp/

	markup directly?



	I mean, _who has the time_? Nobody, that's who:



	|_. Person |_. Has the time?        |

	|   Jake   |     No                 |

	|  Alice   |     No                 |

	|  Rodney  | Not since the accident |

	}



	puts text.to_html

	# <p>Who would ever write

	# <a href="http://www.w3.org/MarkUp/"><span class="caps">HTML</span></a>

	# markup directly?</p>

	#

	# <p>I mean, <em>who has the time</em>? Nobody, that&#8217;s who:</p>

	#

	# <table>

	#  <tr>

	#   <th>Person </th>

	#   <th>Has the time?        </th>

	# </tr>

	# …

	require 'open-uri'



	example = open('http://www.example.com/')

	# => #<StringIO:0xb7bb601c>



	html = example.read

	plain_text = 

html.sub(%r{<body.*?>(.*?)</body>}mi, '\1').gsub(/<.*?>/m, ' ').

	    gsub(%r{(\n\s*){2}}, "\n\n")

	require 'cgi'

	plain_text = CGI.unescapeHTML(plain_text)

	puts plain_text

	# Example 

Web Page

	#

	# You have reached this web page by typing "example.com",

	# "example.net",

	# or "example.org" into your web browser.

	# These domain names are reserved for use in documentation and are not available

	# for registration. See RFC

	# 2606 , Section 3.

	require 'open-uri'

	require 'cgi'



	class HTMLSanitizer

	  attr_accessor :html



	  @@ignore_tags = ['head', 'script', 'frameset' ]

	  @@inline_tags = ['span', 'strong', 'i', 'u' ]

	  @@block_tags = ['p', 'div', 'ul', 'ol' ]

	require 'rubygems'

	require 'RMagick'



	img = 

Magick::Image.read('myimage.jpg').first

	width, height = 100, 100

	thumb = img.resize(width, height)

	thumb.write('mythumbnail.jpg')

	scale_factor = 0.15

	thumb = img.resize(scale_factor)

	thumb.write("mythumbnail.jpg")

	require 'rubygems'

	require 'RMagick'



	img = Magick::Image.read('canyon.png').first

	my_text = "\251 NPS"



	copyright = Magick::Draw.new

	copyright.annotate(img, 0, 0, 3, 18, my_text) do

	 self.font = 'Helvetica'

	 self.pointsize = 12

	 self.font_weight = Magick::BoldWeight

	 self.fill = 'white'

	 self.gravity = Magick::SouthEastGravity

	end

	img.write(' 

canyoncopyrighted.png')

Figure 12-1: With a copyright message in the bottom-right corner

	require 'rubygems'

	require 'RMagick'



	img = Magick::Image.read("canyon.png").first

	my_ 

text = '\251 NPS'



	copyright = Magick::Draw.new

	copyright.font = 'Helvetica'

	copyright.pointsize = 12

	copyright.font_weight = Magick::BoldWeight

	copyright.fill = 'white'

	copyright.gravity = Magick::SouthEastGravity

	copyright.annotate(img, 0, 0, 3, 18, my_text)

	img.write('canyoncopyrighted.png')

	require 'rubygems'

	require 'RMagick'



	img = Magick::Image.read('myimage.png').first

	img.write('myimage.jpg')

	Magick::Image.read("JPG:myimage.png")

	# Magick::ImageMagickError: Not a JPEG file: starts with 0x89 0x50 `myimage.png':

	img = Magick::Image.read("myimage.png").first

	img.write("myimage.jpg")                 # Writes a JPEG

	img.write("myimage.gif")                 # Writes a GIF

	img.write("JPG:myimage")                 # Writes a JPEG

	img.write("JPG:myimage.gif")             # Writes a JPEG

	img.format                               # => "PNG"

	img.format = "GIF"

	img.format                               # => "GIF"

	require 'rubygems'

	require 'gruff'



	g = Gruff::Line.new(600)                 # The graph will be 600 pixels wide.

	g.title = 'Algorithm running times'

	g.theme_37signals                        # The best-looking theme, in my opinion.



	range = (1..101)

	g.data('Constant', range.collect { 1 })

	g.data('O(log n)', range.collect { |x| Math::log(x) / Math::log(2) })

	g.data('O(n)', range.collect { |x| x })

	g.data('O(n log n)', range.collect { |x| x * Math::log(x) / Math::log(2) })



	g.labels = {10 => 'n=10', 50 => 'n=50', 100 => 'n=100' }

	g.write('algorithms.png')

Figure 12-3: A line chart

	p = 

Gruff::Pie.new

	p.theme_monochrome

	p.title = "Survey: the value of pi"

	p.data('"About three"', [3])

	p.data('3.14', [8])

	p.data('3.1415', [11])

	p.data('22/7', [8])



	p.write('pipie.png')

Figure 12-4: A pi chart

	require 'rubygems'

	require ' 

sparklines'

	require 'base64'



	def embedded_sparkline

	  %{<img src="data:image/png;base64,#{Base64.encode64(yield)}">}

	end



	# This method scales data so that the smallest item becomes 0 and the

	# largest becomes 100.

	def scale(data)

	  min, max = data.min, data.max

	  data.collect { |x| (x - min) / (max - min) * 100}

	end



	# Randomly generate closing prices for the past month.

	prices = [rand(10)]

	30.times { prices << prices.last + (rand - 0.5) }



	# Generate HTML containing a stock graph as an embedded sparkline.

	sparkline = embedded_sparkline { Sparklines.plot(scale(prices)) }

	open('stock.html', 'w') do |f|

	  f << "Is EvilCorp (NASDAQ:EVIL #{sparkline}) poised for a comeback?"

	end

Figure 12-5: A stock price history sparkline

	require 'rubygems'

	require 'ezcrypto'



	plaintext = '24.9195N 17.821E'



	ezcrypto_key = EzCrypto::Key.with_password 'My secret key', 'salt string'

	ezcrypto_ciphertext = ezcrypto_key.encrypt(plaintext)

	# => "F\262\260\273\217\tR\351\362-\021-a\336\324Qc…" 

ezcrypto_key.decrypt(ezcrypto_ciphertext)

	# => "24.9195N 17.821E"

	require 'crypt/rijndael'



	aes_key = Crypt::Rijndael.new('My secret key')

	aes_cyphertext = aes_key.encrypt_string(plaintext)

	# => "\e\003\203\030]\203\t\346…"



	aes_key.decrypt_string(aes_cyphertext)

	# => "24.9195N 17.821E"

	# EzCrypto example

	blowfish_key = EzCrypto::Key.with_password('My secret password', 'salt string',

	                                           :algorithm=>'blowfish')

	# Crypt example

	require 'crypt/blowfish'

	blowfish_key = Crypt::Blowfish.new('My secret password')

	require 'csv'

	primary_colors = "red,green,blue\nred,yellow,blue"



	CSV::Reader.parse(primary_colors) { |row| row.each { |cell| puts cell }}

	# red

	# green

	# blue

	# red

	# yellow

	# blue



	require 'rubygems'

	require 'faster_csv'

	shakespeare = %{Sweet are the uses of adversity,As You Like It

	"We few, we happy few",Henry V

	"Seems, madam! nay it is; I know not ""seems.""",Hamlet}



	FasterCSV.parse(shakespeare) { |row| puts "'#{row[0]}' -- #{row[1]}"}

	# 'Sweet are the uses of adversity' -- As You Like It

	# 'We few, we happy few' -- Henry V

	# 'Seems, madam! nay it is; I know not "seems."' -- Hamlet

	require 'csv'



	pipe_separated="1|2ENDa|bEND" 

CSV::Reader.parse(pipe_separated, '|', 'END') { |r| r.each { |c| puts c } }

	# 1

	# 2

	# a

	# b



	require 'rubygems'

	require 'faster_csv'

	FasterCSV.parse(pipe_separated, :col_sep=>'|', :row_sep=>'END') do |r|

	  r.each { |c| puts c }

	end

	# 1

	# 2

	# a

	# b

	data = [[1,2,3],['A','B','C'],['do','re','mi']]



	open('first3.csv', 'w') do |output|

	  CSV::Writer.generate(output, ':', '-END-') do |writer|

	    data.each { |x| writer << x }

	  end

	end

	open('first3.csv') { |input| input.read() }

	# => "1:2:3-END-A:B:C-END-do:re:mi-END-"



	FasterCSV.open('first3.csv', 'w', :col_sep=>':', :row_sep=>'-END-') do |output|

	  data.each { |x| output << x }

	end

	open('first3.csv') { |input| input.read() }

	# => "1:2:3-END-A:B:C-END-do:re:mi-END-"

	require 'rubygems'

	require 'spreadsheet/excel'



	SUM_SPREADSHEET = 'sum.xls'

	workbook = Spreadsheet::Excel.new(SUM_SPREADSHEET)

	worksheet = workbook.add_worksheet('Random numbers and their sum.')

	sum = 0

	random_numbers = (0..9).collect { rand(100) }

	worksheet.write_column(0, 0, random_numbers)



	format = workbook.add_format(:bold => true)

	worksheet.write(10, 0, "Sum:", format)

	worksheet.write(10, 1, random_numbers.inject(0) { |sum, x| sum + x })

	workbook.close

	require ' 

parseexcel/parser'

	workbook = Spreadsheet::ParseExcel::Parser.new.parse(SUM_SPREADSHEET)



	worksheet = workbook.worksheet(0)

	sum = (0..9).inject(0) do |sum, row|



	  sum + worksheet.cell(row, 0).value.to_i

	end



	worksheet.cell(10, 0).value                              # => "Sum:"

	worksheet.cell(10, 1).value                              # => 602.0

	sum                                                      # => 602

	require ' 

zlib'



	file = 'compressed.gz'

	Zlib::GzipWriter.open(file) do |gzip|

	  gzip << "For my next trick, I'll be written to a compressed file."

	  gzip.close

	end



	open(file, 'rb') { |f| f.read(10) }

	# => "\037\213\010\000\201\2766D\000\003"



	Zlib::GzipReader.open(file) { |gzip| gzip.read }

	# => "For my next trick, I'll be written to a compressed file."

	open('compressed.gz', 'wb') do |file|

	  gzip = Zlib::GzipWriter.new(file)

	  gzip << "For my next trick, I'll be written to a compressed file."

	  gzip.close

	end

	deflated = Zlib::Deflate.deflate("I'm a compressed string.")

	# => "x\234\363T\317UHTH…"

	Zlib::Inflate.inflate(deflated)

	# => "I'm a compressed string."

	require 'rubygems'

	require 'zip/zipfilesystem'



	Zip::ZipFile.open('zipfile.zip', Zip::ZipFile::CREATE) do |zip|

	  zip.file.open('file1', 'w') { |f1| f1 << 'This is file 1.' }

	  zip.dir.mkdir('subdirectory')

	  zip.file.open('subdirectory/file2', 'w') { |f1| f1 << 'This is file 2.' }

	end

	def process_zipfile(zip, path='')

	  if zip.file.file? path

	    puts %{#{path}: "#{zip.read(path)}"}

	  else

	    unless path.empty?

	      path += '/'

	      puts path

	    end

	    zip.dir.foreach(path) do |filename|

	      process_zipfile(zip, path + filename)

	    end

	  end

	end

	Zip::ZipFile.open('zipfile.zip') do |zip|

	  process_zipfile(zip)

	end

	# subdirectory/

	# subdirectory/file2: "This is file 2."

	# file1: "This is file 1."

	require 'yaml'

	configuration = { 'color' => 'blue',

	                  'font' => 'Septimus',

	                  'font-size' => 7 }

	open('text.cfg', 'w') { |f| YAML.dump(configuration, f) }



	open('text.cfg') { |f| puts f.read }

	# --

	# font-size: 7

	# color: blue

	# font: Septimus



	open('text.cfg') { |f| YAML.load(f) }

	# => {"font-size"=>7, "color"=>"blue", "font"=>"Septimus"}

	configuration = [ { 'name' => 'Alice', 'donation' => 50 },

	                  { 'name' => 'Bob', 'donation' => 15, 'currency' => "EUR" } ]

	open('donors.cfg', 'w') { |f| YAML.dump(configuration, f) }

	open('donors.cfg') { |f| puts f.read }

	# ---

	# - name: Alice

	#   donation: 50

	# - name: Bob

	#   donation: 15

	#   currency: EUR

	puts { 'measurements' => 'metric' }.to_yaml

	# ---

	# measurements: metric

	puts { :measurements => :metric }.to_yaml

	# ---

	# :measurements: :metric

Figure 12-7: The flyer

	require 'rubygems'

	require ' 

pdf/writer'                                   # => false



	# Putting "false" on the next line suppresses a huge output dump when

	# you run this code in irb.

	 

pdf = PDF::Writer.new; false



	pdf.text("LOST\nDINOSAUR", :justification => :center, :font_size => 42,

	         :left => 50, :right => 50)

	pdf.image("sue.png", :left=> 100, :justification => :center, :resize => 0.75)

	pdf.text(%{Three-year-old <i>Tyrannosaurus rex</i>\nSpayed\nResponds to "Sue"},

	         :left => 80, :font_size => 20, :justification => :left)

	pdf.text("(555) 010-7829", :justification => :center, :font_size => 36)



	pdf.rectangle(pdf.left_margin + 25, pdf.y-25,

	              pdf.margin_width-50, pdf.margin_height-pdf.y+50).stroke; false



	pdf.save_as('flyer.pdf')

	pdf.rectangle(pdf.left_margin, pdf.y-25,

	            pdf.margin_width, pdf.margin_height-pdf.y+25).stroke

	require 'rubygems'

	require 'midilib'                                        # => false



	class Array

	  def to_midi(file, note_length='eighth')



	    midi_max = 108.0

	    midi_min = 21.0



	    low, high = min, max

	    song = MIDI::Sequence.new



	    # Create a new track to hold the melody, running at 120 beats per minute.

	    song.tracks << (melody = MIDI::Track.new(song))

	    melody.events << 

MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(120))



	    # Tell channel zero to use the "piano" sound.

	    melody.events << MIDI::ProgramChange.new(0, 0)



	    # Create a series of note events that play on channel zero.

	    each do |number|

	      midi_note = (midi_min + ((number-midi_min) * (midi_max-low)/high)).to_i

	      melody.events << MIDI::NoteOnEvent.new(0, midi_note, 127, 0)

	      melody.events << MIDI::NoteOffEvent.new(0, midi_note, 127,

	                                              song.note_to_delta(note_length))

	    end



	    open(file, 'w') { |f| song.write(f) }

	  end

	end

	((1..100).collect { |x| x ** 2 }).to_midi('squares.mid')

	require 'yaml'

	

	10.to_yaml               # => "--- 10\n"

	'ten'.to_yaml            # => "--- ten\n"

	'10'.to_yaml             # => "--- \"10\"\n"

	puts %w{Brush up your Shakespeare}.to_yaml

	# --

	# - Brush

	# - up

	# - your

	# - Shakespeare

	puts ({ 'star' => 'hydrogen', 'gold bar' => 'gold' }).to_yaml

	# --

	# star: hydrogen

	# gold bar: gold

	require 'set'

	puts Set.new([1, 2, 3]).to_yaml

	# --- !ruby/object:Set

	# hash:

	#  1: true

	#  2: true

	#  3: true

	users = [{:name => 'Bob', :permissions => ['Read']},

	         {:name => 'Alice', :permissions => ['Read', 'Write']}]

	

	# Serialize

	open('users', 'w') { |f| YAML.dump(users, f) }



	# And deserialize

	users2 = open("users") { |f| YAML.load(f) }

	# => [{:permissions=>["Read"], :name=>"Bob"},

	#     {:permissions=>["Read", "Write"], :name=>"Alice"}]

	Marshal.dump(10)                              # => "\004\010i\017"

	Marshal.dump('ten')                           # => "\004\010\"\010ten"

	Marshal.dump('10')                            # => "\004\010\"\a10"



	Marshal.load(Marshal.dump(%w{Brush up your Shakespeare}))

	# => ["Brush", "up", "your", "Shakespeare"]



	require 'set'

	Marshal.load(Marshal.dump(Set.new([1, 2, 3])))

	# => #<Set: {1, 2, 3}>

	Marshal.dump(Set)                 # =>"\004\010c\010Set"

	#!/usr/bin/ruby -w



	Marshal.load("\004\010c\010Set")

	# ArgumentError: undefined class/module Set

	#!/usr/bin/ruby -w

	# poll.rb

	require 'rubygems'

	require 'madeleine'



	class Poll

	  attr_accessor :name

	  attr_reader :total



	  def initialize(name)

	    @name = name

	    @total = 0

	  end



	  def agree

	    @total += 1

	  end



	  def disagree

	    @total -= 1

	  end

	end

	poll = SnapshotMadeleine.new('poll_data') do

	  Poll.new('Is Ruby great?')

	end

	if ARGV[0] == 'agree'

	  poll.system.agree

	elsif ARGV[0] == 'disagree'

	  poll.system.disagree

	end



	puts "Name: #{poll.system.name}"

	puts "Total: #{poll.system.total}"

	poll.take_snapshot

	$ ruby poll.rb agree

	Name: Is Ruby great?

	Total: 1



	$ ruby poll.rb agree

	Name: Is Ruby great?

	Total: 2



	$ ruby poll.rb disagree

	Name: Is Ruby great?

	Total: 1

	poll = SnapshotMadeleine.new('poll_data') do

	  Poll.new('Is Ruby great?')

	end

	require 'rubygems'

	require 'search/simple'



	contents = Search::Simple::Contents.new

	contents << Search::Simple::Content.

	              new('In the beginning God created the heavens…',

	                  'Genesis.txt', Time.now)

	contents << Search::Simple::Content.new('Call me Ishmael…',

	                                    'MobyDick.txt', Time.now)

	contents << Search::Simple::Content.new('Marley was dead to begin with…',

	                                    'AChristmasCarol.txt', Time.now)



	searcher = Search::Simple::Searcher.load(contents, 'index_file')

	require 'rubygems'

	require 'search/simple'



	searcher = nil

	open('index_file') do |f|

	  searcher = Search::Simple::Searcher.new(Marshal.load(f), Marshal.load(f),

	                                          'index_file')

	end



	searcher.find_words(['begin']).results.collect { |result| result.name }

	# => ["AChristmasCarol.txt", "Genesis.txt"]

	require 'rubygems'

	require 'ferret'



	PACKAGE_INDEX_DIR = 'ruby_packages/'

	Dir.mkdir(PACKAGE_INDEX_DIR) unless File.directory? PACKAGE_INDEX_DIR

	index = 

Ferret::Index::Index.new(:path => PACKAGE_INDEX_DIR,

	                                 :default_search_field => 'name|description')

	index << { :name => 'SimpleSearch',

	           :description => 'A simple indexing library.',

	           :supports_structured_data => false,

	           :complexity => 2 }

	index << { :name => ' 

Ferret',

	           :description => 'A Ruby port of the Lucene library.

	                            More powerful than SimpleSearch',

	           :supports_structured_data => true,

	           :complexity => 5 }

	index.search_each('library') do |doc_id, score|

	  puts index.doc(doc_id).field('name').data

	end

	# SimpleSearch

	# Ferret



	index.search_each('description:powerful AND supports_structured_data:true') do

	|doc_id, score|

	  puts index.doc(doc_id).field("name").data

	end

	# Ferret



	index.search_each("complexity:<5") do |doc_id, score|

	  puts index.doc(doc_id).field("name").data

	end

	# SimpleSearch

	require 'dbm'



	DBM.new('random_thoughts') do |db|

	  db['tape measure'] =

	    "What if there was a tape measure you could use as a yo-yo?"

	  db[23] = "Fnord."

	end



	DBM.open('random_thoughts') do |db|

	  puts db['tape measure']

	  puts db['23']

	end

	# What if there was a tape measure you could use as a yo-yo?

	# Fnord.



	DBM.open('random_thoughts') { |db| db[23] }

	# TypeError: can't convert Fixnum into String



	Dir['random_thoughts.*']

	# => ["random_thoughts.pag", "random_thoughts.dir"]

	def mysql(opts, stream)

	  IO.popen("mysql #{opts}", 'w') { |io| io.puts stream }

	end

	mysql '-u root -p[password]', <<-end

	  drop database if exists website_db;

	  create database website_db;

	  grant all on website_db.* to #{`id -un`.strip}@localhost;

	end

	require 'cookbook_dbconnect'



	with_db do |c|



 	  c.do %{drop table if exists letters}



	  c.do %{create table letters(id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,

	                          letter CHAR(1) NOT NULL)}

	  letter_sql = ('a'..'z').collect.join('"),("')



	  c.do %{insert into letters(letter) values ("#{letter_sql}")}

	end

	# => 26

	vowel_query = %{select id from letters where letter in ("a","e","i","o","u")}

	with_db do |c|

	  h = c.execute vowel_query

	  "My collection contains #{h.rows} vowels."

	end

	# => "My collection contains 5 vowels."

	with_db do |c|

	  vowels = c.select_all(vowel_query)

	  "My collection still contains #{vowels.size} vowels."

	end

	# => "My collection still contains 5 vowels."

	require 'rubygems'

	require 'mysql'



	def with_db

	  dbh = Mysql.real_connect('localhost', 'cookbook_user', 'password',

	                           'cookbook')

	  begin

	    yield dbh

	  ensure

	    dbh.close

	  end

	end

	with_db do |db|

	  db.query('drop table if exists secrets')

	  db.query('create table secrets( id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,

	                                 secret LONGTEXT )')

	  db.query(%{insert into secrets(secret) values

	     ("Oh, MySQL, you're the only one who really understands me.")})

	end

	with_db do |db|

	  res = db.query('select * from secrets')

	  res.each { |row| puts "#{row[0]}: #{row[1]}" }

	  res.free

	end

	# 1: Oh, MySQL, you're the only one who really understands me.

	class Mysql

	  alias :query_no_block :query

	  def query(sql)

	    res = query_no_block(sql)

	    return res unless block_given?

	    begin

	      yield res

	    ensure

	      res.free if res

	    end

	  end

	end

	require 'rubygems'

	require 'postgres'



	def with_db

	  db = PGconn.connect('localhost', 5432, '', '', 'cookbook',

	                      'cookbook_user', 'password')

	  begin

	    yield db

	  ensure

	    db.close

	  end

	end

	with_db do |db|

	  begin

	    db.exec('drop table secrets')

	  rescue PGError

	    # Unlike MySQL, Postgres does not have a "drop table unless exists"

	    # command. We can simulate it by issuing a "drop table" command and

	    # ignoring any error due to the table not existing in the first place.

	    # This is essentialy what MySQL's "drop table unless exists" does.

	  end



	  db.exec('create table secrets( id SERIAL PRIMARY KEY,

	                                 secret TEXT )')

	  db.exec(%{insert into secrets(secret) values

	            ('Oh, Postgres, you\\'re the only one who really understands me.')})

	end

	with_db do |db|

	  res = db.query('select * from secrets')

	  res.each { |row| puts "#{row[0]}: #{row[1]}" }

	end

	# 1: Oh, Postgres, you're the only one who really understands me.

	use cookbook;



	DROP TABLE IF EXISTS blog_posts;

	CREATE TABLE blog_posts (

	  id INT(11) NOT NULL AUTO_INCREMENT,

	  title VARCHAR(200),

	  content TEXT,

	  PRIMARY KEY (id)

	) ENGINE=InnoDB;



	DROP TABLE IF EXISTS comments;

	CREATE TABLE comments (

	  id INT(11) NOT NULL AUTO_INCREMENT,

	  blog_post_id INT(11),

	  author VARCHAR(200),

	  content TEXT,

	  PRIMARY KEY (id)

	) ENGINE=InnoDB;

	require 'cookbook_dbconnect'

	activerecord_connect                  # See chapter introduction



	class BlogPost < ActiveRecord::Base

	  has_many :comments

	end



	class Comment < ActiveRecord::Base

	  belongs_to :blog_post

	end

	post = BlogPost.create(:title => 'First post',

	                       :content => "Here are some pictures of our iguana.")



	comment = Comment.create(:blog_post => post, :author => 'Alice',

	                         :content => "That's one cute iguana!")



	post.comments.create(:author => 'Bob', :content => 'Thank you, Alice!')

	blog_post = BlogPost.find(:first)



	puts %{#{blog_post.comments.size} comments for "#{blog_post.title}"}

	# 2 comments for "First post"



	blog_post.comments.each do |comment|

	  puts "Comment author: #{comment.author}"

	  puts "Comment: #{comment.content}"

	end

	# Comment author: Alice

	# Comment: That's one cute iguana!

	# Comment author: Bob

	# Comment: Thank you, Alice!



	first_comment = Comment.find(:first)

	puts %{The first comment was made on "#{first_comment.blog_post.title}"}

	# The first comment was made on "First post"

	require 'cookbook_dbconnect'

	require 'og'



	class BlogPost

	  property :title, :content, String

	end



	class Comment

	  property :author, :content, String

	  belongs_to : 

og_post,  

BlogPost

	end



	# Now that Comment's been defined, add a reference to it in BlogPost.

	class BlogPost

	  has_many :comments, Comment

	end

	og_connect

	# Og uses the Mysql store.

	# Created table 'ogcomment'.

	# Created table 'ogblogpost'.

	post = BlogPost.new

	post.title = "First post"

	post.content = "Here are some pictures of our iguana."

	post.save!



	[["Alice", "That's one cute iguana!"],

	 ["Bob", "Thank you, Alice!"]].each do |author, content|

	  comment = Comment.new

	  comment.blog_post = post

	  comment.author = author

	  comment.content = content

	  comment.save!

	end

	post = BlogPost.first

	puts %{#{post.comments.size} comments for "#{post.title}"}

	# 2 comments for "First post"



	post.comments.each do |comment|

	  puts "Comment author: #{comment.author}"

	  puts "Comment: #{comment.content}"

	end

	# Comment author: Alice

	# Comment: That's one cute iguana!

	# Comment author: Bob

	# Comment: Thank you, Alice!



	puts %{The first comment was made on "#{Comment.first.blog_post.title}"}

	# The first comment was made on "First post"

	require 'cookbook_dbconnect'



	class ActiveRecord::Base

	  def self.find_by_map(id, args={}.freeze)

	    sql = []

	    values = []

	    args[:conditions].each do |field, value|

	      sql << "#{field} = ?"

	      values << value

	    end if args[:conditions]

	    args[:conditions] = [sql.join(' AND '), values]

	    find(id, args)

	  end

	end

	activerecord_connect



	class BlogPost < ActiveRecord::Base

	end



	BlogPost.create(:title => 'Game Review: Foosball Carnage',

	                :content => 'Four stars!')

	BlogPost.create(:title => 'Movie Review: Foosball Carnage: The Movie',

	                :content => 'Zero stars!')



	BlogPost.find_by_map(:first,

	                     :conditions => {:title =>

	                                     'Game Review: Foosball Carnage' }

	                    ).content

	# => "Four stars!"

	require 'cookbook_dbconnect'

	activerecord_connect

	

	class Comment < ActiveRecord::Base

	  @@profanity = %w{trot krip}

	  @@no_profanity_re = Regexp.new('^(?!.*(' + @@profanity.join('|') + '))')



	  validates_presence_of %w{author}

	  validates_length_of :content, :in => 1..200

	  validates_format_of :content, :with => @@no_profanity_re,

	                      :message => 'contains profanity'

	end

	comment = Comment.create

	comment.errors.on 'author'                       # => "can't be blank"

	comment.errors['content']

	# => "is too short (minimum is 1 characters)"

	comment.save                                     # => false



	comment = Comment.create(:content => 'x' * 1000)

	comment.errors['content']

	# => "is too long (maximum is 200 characters)"



	comment = Comment.create(:author => 'Alice',

	  :content => "About what I'd expect from a trotting krip such as yourself!")

	comment.errors.count                             # => 1

	comment.errors.each_full { |msg| puts msg }

	# Content contains profanity



	comment = Comment.create(:author => 'Alice', :content => 'I disagree!')

	comment.save                                     # => true

	use cookbook;



	DROP TABLE IF EXISTS names;

	CREATE TABLE names (

	  first VARCHAR(200),

	  last VARCHAR(200)

	) ENGINE=InnoDB;



	INSERT INTO names values ('Leonard', 'Richardson'),

	                         ('Lucas', 'Carlson'),

	                         ('Michael', 'Loukides');

	#!/usr/bin/ruby

	# no_sql_injection.rb



	require 'cookbook_dbconnect'

	activerecord_connect

	class Name < ActiveRecord::Base; end



	print 'Enter a last name to search for: '

	search_for = readline.chomp



	# Technique 1: use ActiveRecord question marks

	conditions = ["last = ?", search_for]



	Name.find(:all, :conditions => conditions).each do |r|

	  puts %{Matched "#{r.first} #{r.last} with ActiveRecord question marks"}

	end



	# Technique 2: use ActiveRecord named variables

	conditions = ["last = :last", {:last => search_for}]

	

	Name.find(:all, :conditions => conditions).each do |r|

	  puts %{Matched "#{r.first} #{r.last}" with ActiveRecord named variables}

	end



	# Technique 3: use DBI question marks

	with_db do |db|

	  sql = 'SELECT first, last FROM names WHERE last = ?'



	  db.execute(sql, [search_for]).fetch_hash do |r|

	    puts %{Matched "#{r['first']} #{r['last']}" with DBI question marks}

	  end

	end

	

	puts "Done"

	$ ruby no_sql_injection.rb

	Enter a last name to search for: Richardson

	Matched "Leonard Richardson" with ActiveRecord question marks

	Matched "Leonard Richardson" with ActiveRecord named variables

	Matched "Leonard Richardson" with DBI question marks

	Done



	# See the Discussion if you're not sure how this attack is supposed to work.

	$ ruby no_sql_injection.rb

	Enter a last name to search for: " or 1=1

	Done

	require 'cookbook_dbconnect'

	activerecord_connect # See chapter introduction



	class User < ActiveRecord::Base

	  has_and_belongs_to_many :blog_posts

	end



	class BlogPost < ActiveRecord::Base

	  has_and_belongs_to_many :authors, :class_name => 'User'

	end

	require 'active_record/ 

transactions'



	class BlogPost

	  def BlogPost.create_from_new_author(author_name, title, content)

	    transaction do

	      author = User.create(:name => author_name)

	      raise 'Random failure!' if rand(2) == 0

	      create(:authors => [author], :title => title, :content => content)

	    end

	  end

	end

	BlogPost.create_from_new_author('Carol', 'The End Is Near',

	                                'A few more facts of doom…')

	# => #<BlogPost:0xb78b7c7c … >



	# The method succeeded; Carol's in the database:

	User.find(:first, :conditions=>"name='Carol'")

	# => #<User:0xb7888ae4 @attributes={"name"=>"Carol", … }>

	

	# Let's do another one…

	BlogPost.create_from_new_author('David', 'The End: A Rebuttal',

	                                'The end is actually quite far away…')

	# RuntimeError: Random failure!



	# The method failed; David's not in the database:

	User.find(:first, :conditions=>"name='David'")

	# => nil

	require 'cookbook_dbconnect'

	require 'og'

	require 'glue/aspects'



	class BlogPost

	  property :title, :content, String

	  after :on => :og_insert do |post|

	    puts %{Sending email notification of new post "#{post.title}"}

	    # Actually send the email here…

	    end

	end



	og_connect

	post = BlogPost.new

	post.title = 'Robots are taking over'

	post.content = 'Think about it! When was the last time you saw another human?'

	post.save!

	# Sending email notification of new post "Robots are taking over"

	require 'cookbook_dbconnect'

	activerecord_connect



	class BlogPost < ActiveRecord::Base

	  def after_create

	    puts %{Sending email notification of new blog post "#{title}"}

	    # Actually send the email here…

	  end

	end



	post = BlogPost.create(:title => 'Robots: Gentle Yet Misunderstood',

	                       :content => 'Popular misconceptions about robERROR 40')

	# Sending email notification of new blog post "Robots: Gentle Yet Misunderstood

	require 'cookbook_dbconnect'

	require 'og'

	require 'glue/taggable'



	class BlogPost

	  is Taggable

	  property :title, :content, String

	end

	og_connect



	# Now we can play around with tags.

	post = BlogPost.new

	post.title = 'Some more facts about video games'

	post.tag(['editorial', 'games'])

	

	BlogPost.find_with_tags('games').each { |puts| puts post.title }

	# Some more facts about video games



	Tag.find_by_name('editorial').blog_posts.each { |post| puts post.title }

	# Some more facts about video games

	DROP TABLE IF EXISTS tags;

	CREATE TABLE tags (

	  id INT(11) NOT NULL AUTO_INCREMENT,

	  name VARCHAR(32),

	  PRIMARY KEY (id)

	) ENGINE=InnoDB;



	DROP TABLE IF EXISTS tags_blog_posts;

	CREATE TABLE tags_blog_posts (

	   tag_id INT(11),

	   blog_post_id INT(11)

	) ENGINE=InnoDB;

	require ' 

open-uri'

	puts open('http://www.oreilly.com/').read(200)

	# <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

	#         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

	# <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

	require ' 

net/http'

	response = Net::HTTP.get_response('www.oreilly.com', '/about/')

	response.code                                             # => "200"

	response.body.size                                        # => 21835

	response['Content-type']

	# => "text/html; charset=ISO-8859-1"

	puts response.body[0,200]

	# <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

	#    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

	#

	#

	# <html>

	# <head>

	# <meta http-equiv="content-type" content="text/html; c

	require 'uri'

	Net::HTTP.get(URI.parse("http://www.oreilly.com"))

	Net::HTTP.get_response(URI.parse("http://www.oreilly.com/about/"))

	require 'net/https'                       # => true

	require 'net/http'

	uri = URI.parse("https://www.donotcall.gov/")



	request = Net::HTTP.new(uri.host, uri.port)

	response = request.get("/")

	# Errno::ECONNRESET: Connection reset by peer



	require 'net/https'

	request.use_ssl = true

	request.verify_mode = OpenSSL::SSL::VERIFY_NONE

	response = request.get("/")

	# => #<Net::HTTPOK 200 OK readbody=true>

	response.body.size                              # => 6537

	require 'net/http'

	require 'uri'



	#A simple wrapper method that accepts either strings or URI objects

	#and performs an HTTP GET.

	module Net

	  class HTTP

	    def HTTP.get_with_headers(uri, headers=nil)

	      uri = URI.parse(uri) if uri.respond_to? :to_str

	      start(uri.host, uri.port) do | 

http|

	        return  

http.get(uri.path, headers)

	      end

	    end

	  end

	end



	#Let's get a web page in German.

	res = Net::HTTP.get_with_headers('http://www.google.com/',

	                                 {' 

Accept-Language' => 'de'})



	#Check a bit of the body to make sure it's really in German.

	s = res.body.size

	res.body[s-200..s-140]

	# => "ngebote</a> - <a href=/intl/de/about.html>Alles \374ber Google</"

	Net::HTTP.get_with_headers(url, {'User-Agent' => 'Ruby Web Browser v1.0'})

	uncompressed = Net::HTTP.get_with_headers('http://www.cnn.com/')

	uncompressed.body.size

	# => 65150



	gzipped = Net::HTTP.get_with_headers('http://www.cnn.com/',

	                                     {'Accept-Encoding' => 'gzip'})

	gzipped['Content-Encoding']

	# => "gzip"

	gzipped.body.size

	# => 14600



	require 'zlib'

	require 'stringio'

	body_io = StringIO.new(gzipped.body)

	unzipped_body = Zlib::GzipReader.new(body_io).read()

	unzipped_body.size

	# => 65150

	require 'resolv' 

Resolv::DNS.new.each_address("oreilly.com") { |addr| puts addr }

	# 208.201.239.36

	# 208.201.239.37

	dns = 

Resolv::DNS.new

	domain = "oreilly.com"

	dns.each_resource(domain, Resolv::DNS::Resource::IN::MX) do |mail_server|

	  puts mail_server.exchange

	end

	# smtp1.oreilly.com

	# smtp2.oreilly.com



	dns.each_resource(domain, Resolv::DNS::Resource::IN::NS) do |nameserver|

	  puts nameserver.name

	end

	# a.auth-ns.sonic.net

	# b.auth-ns.sonic.net

	# c.auth-ns.sonic.net

	# ns.oreilly.com

	require 'rubygems'

	require 'action_mailer'



	class SimpleMailer < ActionMailer::Base

	  def simple_message(recipient)

	     from 'leonardr@example.org'

	     recipients recipient

	     subject 'A single-part message for you'

	     body 'This message has a plain text body.'

	   end

	end

	puts SimpleMailer. 

create_simple_message('lucas@example.com')

	# From: leonardr@example.org

	# To: lucas@example.com

	# Subject: A single-part message for you

	# Content-Type: text/plain; charset=utf-8

	#

	# This message has a plain text body.

	ActionMailer::Base.server_settings = { :address => 'localhost',

	                                       :port => 25, # 25 is the default

	                                       :domain => 'example.org' }



	SimpleMailer.deliver_simple_message('lucas@example.com')

	require 'net/imap'



	conn = Net::IMAP.new('mail.myhost.com', 143)

	conn.login('username', 'password')

	conn.examine('INBOX')

	# Use Net::IMAP#select instead for read-only access

	conn.search(['FROM', 'jabba@huttfoundation.org']).each do |sequence|

	    fetch_result = conn.fetch(sequence, 'ENVELOPE')

	    envelope = fetch_result[0].attr['ENVELOPE']

	    printf("%s - From: %s - To: %s - Subject: %s\n", envelope.date,

	         envelope.from[0].name, envelope.to[0].name, envelope.subject)

	end

	# Wed Feb 08 14:07:21 EST 2006 - From: The Hutt Foundation - To: You - Subject: Bwah!

	# Wed Feb 08 11:21:19 EST 2006 - From: The Hutt Foundation - To: You - Subject: Go to

	# do wa IMAP

	require 'net/pop'



	conn = Net::POP3.new('mail.myhost.com')

	conn.start('username', 'password')

	require 'net/pop'



	conn = Net::POP3.new('mail.myhost.com')

	conn.start('username', 'password')



	conn.mails.each do |msg|

	   File.open(msg.uidl, 'w') { |f| f.write msg.pop }

	   # msg.delete

	end



	conn.finish

	require 'net/ftp'

	ftp = 

Net::FTP.open('ftp.ibiblio.org') do |ftp|

	  ftp.login

	  ftp.chdir('pub/linux/')

	  ftp.list('*Linux*') { |file| puts file }

	  puts



	  puts 'Saving a text file to disk while processing it.'

	  ftp.gettextfile('How-do-I-get-Linux') { |line| puts "! #{line}" }

	  puts "Saved #{File.size 'How-do-I-get-Linux'} bytes."

	  puts



	  puts 'Saving a binary file to disk.'

	  ftp.getbinaryfile('INDEX.whole.gz')

	 puts "Saved #{File.size 'INDEX.whole.gz'} bytes."

	end

	# -rw-r--r--   1 (?)      users    16979001 Jan 1 11:31 00-find.Linux.gz

	# -rw-rw-r--   1 (?)      admin          73 Mar 9  2001 How-do-I-get-Linux



	# Saving a text file to disk while processing it.

	# !

	# !   Browse to http://metalab.unc.edu/linux/HOWTO/Installation-HOWTO.html

	# !

	# Saved 73 bytes.



	# Saving a binary file to disk.

	# Saved 213507 bytes.

	ftp.login('leonardr', 'mypass')

	require 'net/telnet'



	webserver = Net::Telnet::new('Host' => 'www.oreilly.com',

	                             'Port' => 80,

	                             'Telnetmode' => false)



	size = 0

	webserver.cmd("GET / HTTP/1.1\nHost: www.oreilly.com\n") do |c|

	  size += c.size

	  puts "Read #{c.size} bytes; total #{size}"

	end

	# Read 1431 bytes; total 1431

	# Read 1434 bytes; total 2865

	# Read 1441 bytes; total 4306

	# Read 1436 bytes; total 5742

	# …

	# Read 1430 bytes; total 39901

	# Read 2856 bytes; total 42757

	# /usr/lib/ruby/1.8/net/telnet.rb:551:in 'waitfor':

	#   timed out while waiting for more data (Timeout::Error)

	require 'rubygems'

	require 'net/ssh' 

Net::SSH.start('example.com', :username=>'leonardr',

	               :password=>'mypass') do |session|

	  # Manipulate your Net::SSH::Session object here…

	end

	require 'rubygems'

	require 'net/ssh'



	def copy_file(session, source_path, destination_path=nil)

	  destination_path ||= source_path

	  cmd = %{cat > "#{destination_path.gsub('"', '\"')}"}

	  session.process.popen3(cmd) do |i, o, e|

	    puts " 

Copying #{source_path} to #{destination_path}… "

	    open(source_path) { |f| i.write(f.read) }

	    puts 'Done.'

	  end

	end



	Net::SSH.start('example.com', :username=>'leonardr',

	               :password=>'mypass') do |session|

	  copy_file(session, '/home/leonardr/scripts/test.rb')

	  copy_file(session, '/home/leonardr/scripts/"test".rb')

	end

	# Copying /home/leonardr/scripts/test.rb to /home/leonardr/scripts/test.rb…

	# Done.

	# Copying /home/leonardr/scripts/"test".rb to /home/leonardr/scripts/"test".rb…

	# Done.

	def do_copy(session, source_path, destination_path=nil)

	  destination_path ||= source_path

	  cmd = %{cat > "#{destination_path.gsub('"', '\"')}"}

	  cat_process = session.process.open(cmd)



	  cat_process.on_success do |p|

	    p.write(open(source_path) { |f| f.read })

	    p.close

	    puts "Copied #{source_path} to #{destination_path}."

	  end

	end

	require 'rubytorrent'

	file = 'http://publicdomaintorrents.com/bt/btdownload.php?type=torrent' +

	        '&file=Night_of_the_Living_Dead.avi.torrent'

	client = RubyTorrent::BitTorrent.new(file)

	client.num_active_peers                     # => 9

	# That is, 9 other people are downloading this file along with me.



	client.ulrate                               # => 517.638825414351

	client.dlrate                               # => 17532.608916979

	# That is, about 3 kb/sec uploading and 17 kb/sec downloading.



	client.percent_completed                    # => 0.25

	require 'ping' 

ping.pingecho('oreilly.com') 	                         # => true



	# timeout of 10 seconds instead of the default 5 seconds

	Ping.pingecho('127.0.0.1', 10)                           # => true

	#  

ping port 80 instead of the default echo port

	 

Ping.pingecho('slashdot.org', 5, 80)                     # => true



	 

Ping.pingecho('no.such.domain')                          # => false

	 

Ping.pingecho('222.222.222.222')                         # => false

	system('ping -c1 www.oreilly.com')

	# 64 bytes from 208.201.239.36: icmp_seq=0 ttl=42 time=27.2 ms

	#

	# --- www.oreilly.com ping statistics --

	# 1 packets transmitted, 1 packets received, 0% packet loss

	# round-trip min/avg/max = 27.2/27.2/27.2 ms

	# => true

	ping.pingecho('microsoft.com')                          # => false



	require 'net/http'

	Net::HTTP.start('microsoft.com') { 'success!' }         # => "success!"

	Net::HTTP.start('no.such.domain') { "success!" }

	# SocketError: getaddrinfo: Name or service not known

	#!/usr/bin/ruby -w

	# chat.rb

	require ' 

gserver'



	class ChatServer < GServer



	  def initialize(port=20606, host=GServer::DEFAULT_HOST)

	    @clients = []

	    super(port, host, Float::MAX, $stderr, true)

	  end



	  def serve(sock)

	    begin

	      @clients << sock

	      hostname = sock.peeraddr[2] || sock.peeraddr[3]

	      @clients.each do |c|

	        c.puts "#{hostname} has joined the chat." unless c == sock

	      end

	      until sock.eof? do

	        message = sock.gets.chomp

	        break if message == "/quit"

	        @clients.each { |c| c.puts "#{hostname}: #{message}" unless c == sock }

	      end

	    ensure

	      @clients.delete(sock)

	      @clients.each { |c| c.puts "#{hostname} has left the chat." }

	    end

	  end

	end



	server = ChatServer.new(*ARGV[0..2] || 20606)

	server.start(-1)

	server.join

	require 'uri'



	URI.parse('https://www.example.com').scheme           # => "https"

	URI.parse('http://www.example.com/').host             # => "www.example.com"

	URI.parse('http://www.example.com:6060/').port        # => 6060

	URI.parse('http://example.com/a/file.html').path      # => "/a/file.html"

	URI.split('http://example.com/a/file.html')

	# => ["http", nil, "example.com", nil, nil, "/a/file.html", nil, nil, nil]

	URI::HTTP.component

	# => [:scheme, :userinfo, :host, :port, :path, :query, :fragment]



	URI::MailTo.component

	# => [:scheme, :to, :headers]

	URI::HTTP.build(:host => 'example.com', :path => '/a/file.html',

	                :fragment => 'section_3').to_s

	# => "http://example.com/a/file.html#section_3"

	#!/usr/bin/ruby

	# ps.cgi



	processes = %x{ps aux}.collect do |proc|

	  '<tr><td>' + proc.split(/\s+/, 11).join('</td><td>') + '</td></tr>'

	end



	puts 'Content-Type: text/html'

	# Output other HTTP headers here…

	puts "\n"



	title = %{Processes running on #{ENV['SERVER_NAME'] || `hostname`.strip}}

	puts <<-end

	  <HTML>

	   <HEAD><TITLE>#{title}</TITLE></HEAD>

	   <BODY>

	   <H1>#{title}</H1>

	   <TABLE>

	    #{processes.join("\n")}

	  </TABLE>

	  </BODY>

	  </HTML>

	end



	exit 0

	#!/usr/bin/ruby

	# headers.cgi



	require "cgi"

	cgi = CGI.new("html3")



	# Retrieve or create the "rubycookbook" cookie

	cookie = cgi. 

cookies['rubycookbook']

	cookie = CGI::Cookie.new('rubycookbook', 'hits=0',

	                         "last=#{Time.now}") if cookie.empty?



	# Read the values in the cookie for future use

	hits = cookie.value[0].split('=')[1]

	last = cookie.value[1].split('=')[1]



	# Set new values in the cookie

	cookie.value[0] = "hits=#{hits.succ}"

	cookie.value[1] = "last=#{Time.now}"

	# Create a hash of HTTP response headers.

	header = { 'status'      => 'OK',

	           'cookie'      => [cookie],

	           'Refresh'     => 2,

	           'Recipe Name' => 'Setting HTTP Response Headers',

	           'server'      => ENV['SERVER_SOFTWARE'] }



	cgi.out(header) do

	  cgi.html('PRETTY' => ' ') do

	    cgi.head { cgi.title { 'Setting HTTP Response Headers' } } +

	    cgi.body do

	      cgi.p('Your headers:') +

	      cgi.pre{ cgi.header(header) } +

	      cgi.pre do

	        "Number of times your browser hit this cgi: #{hits}\n"+

	        "Last connected: #{last}"

	      end

	    end

	 end

	end

	#!/usr/bin/ruby

	# upload.rb



	# Save uploaded files to this directory

	UPLOAD_DIR = "/usr/local/www/uploads"



	require 'cgi'

	require 'stringio'

	def display_form(cgi)

	 action = env['script_name']

	 return <<EOF

	<form action="#{action}" method="post" enctype="multipart/form-data">

	 File to Upload: <input type="file" name="file_name"><br>

	 Your email address: <input type="text" name="email_address"

	                      value="guest@example.com"><br>

	 <input type="submit" name="Submit" value="Submit Form">

	 </form>

	EOF

	end

	def process_form(cgi)

	  email = cgi.params['email_address'][0] 

fileObj = cgi.params['file_name'][0]



	  str = '<h1>Upload report</h1>' +

	    "<p>Thanks for your upload, #{email.read}</p>"

	  if fileObj

	    path = fileObj.original_filename

	    str += "Original Filename : #{path}" + cgi.br

	    dest = File.join(UPLOAD_DIR, sanitize_filename(path))



	    str += "Destination : #{dest} <br>"

	    File.open(dest.untaint, 'wb') { |f| f << fileObj.read }



	    # Delete the temporary file if one was created

	    local_temp_file = fileObj.local_path()

	    File.unlink(local_temp_file) if local_temp_file

	  end

	  return str

	end

	#!/usr/bin/ruby

	# simple_servlet_server.rb

	require 'webrick'

	include WEBrick



	s = HTTPServer.new(:Port => 8000)

	# Add a mime type for *.rhtml files

	HTTPUtils::DefaultMimeTypes.store('rhtml', 'text/html')



	# Required for CGI on Windows; unnecessary on Unix/Linux

	s.config.store( :CGIInterpreter, "#{HTTPServlet::CGIHandler::Ruby}")



	# Mount 

servlets

	s.mount('/',       HTTPServlet::FileHandler, '/var/www/html')

	s.mount('/bruce',  HTTPServlet::FileHandler, '/home/dibbbr/htdoc')

	s.mount('/marty',  HTTPServlet::FileHandler, '/home/wisema/htdoc')



	# Trap signals so as to shutdown cleanly.

	['TERM', 'INT'].each do |signal|

	  trap(signal){ s.shutdown }

	end



	# Start the server and block on input.

	s.start

	$ rails status

	      create

	      create app/controllers

	      create app/helpers

	      create app/models

	      create app/views/layouts

	      create config/environments

	…

	$ cd status

	$ ./script/generate controller status index

	      exists app/controllers/

	      exists app/helpers/

	      create app/views/status

	      exists test/functional/

	      create app/controllers/status_controller.rb

	      create test/functional/status_controller_test.rb

	      create app/helpers/status_helper.rb

	      create app/views/status/index.rhtml

	class StatusController < ApplicationController

	  def index

	    # This variable won't be accessible to the view, since it is local

	    # to this method

	    time = Time.now

	

	    # These variables will be accessible in the view, since they are

	    # instance variables of the StatusController.

	    @time = time

	    @ps = 'ps aux'

	  end

	end

	class NovelController < ApplicationController

	  def index

	    @title = 'Shattered View: A Novel on 

Rails'

	    one_plus_one = 1 + 1

	    increment_counter one_plus_one

	  end



	  def helper_method

	    @help_message = "I see you've come to me for help."

	  end



	  private



	  def increment_counter(by)

	    @counter ||= 0

	    @counter += by

	  end

	end

	<h1><%= @title %></h1>

	

	<p>I looked up, but saw only the number <%= @counter %>.</p>

	

	<p>"What are you doing here?" I asked sharply. "Was it <%=

	@counter.succ %> who sent you?"</p>

	<html>

	  <head>

	    <title>My Website</title>

	 </head>

	  <body>

	    <%= @content_for_layout %>

	  </body>

	</html>

	class StatusController < ActionController:Base

	  def index

	    @title = "System Status"

	  end

	end

	<html>

	  <head>

	     <title>My Website - <%= @title %></title>

	  </head>

	  <body>

	     <%= @content_for_ 

layout %>

	  </body>

	</html>

	class BureaucracyController < ApplicationController

	  def index

	    redirect_to :controller => 'bureaucracy', :action => 'reservation_window'

	  end



	  def reservation_window

	    redirect_to :action => 'claim_your_form', :id => 123

	  end



	  def claim_your_form

	    redirect_to :action => 'fill_out_your_form', :id => params[:id]

	  end



	  def fill_out_your_form

	    redirect_to :action => 'form_processing'

	  end



	  def form_processing

	    redirect_to "http://www.dmv.org/"

	  end

	end

	"GET /bureaucracy HTTP/1.1" 302

	"GET /bureaucracy/reservation_window HTTP/1.1" 302

	"GET /bureaucracy/claim_your_form/123 HTTP/1.1" 302

	"GET /bureaucracy/fill_out_your_form/123 HTTP/1.1" 302

	"GET /bureaucracy/form_processing HTTP/1.1" 302

	class ListController < ApplicationController

	  def index

	    @list = ['papaya', 'polio vaccine']

	    render :action => 'shopping_list'

	  end



	  def shopping_list

	    @list = ['cotton balls', 'amino acids', 'pie']

	  end

	end

	class ListController < ApplicationController

	  def index

	    render :action => 'shopping_list'

	    @budget = 87.50

	  end



	  def shopping_list

	    @list = ['lizard food', 'baking soda']

	  end

	end

	development:

	adapter: mysql

	database: mywebapp_development

	host: localhost

	username: root

	password:



	test:

	adapter: mysql

	database: mywebapp_test

	host: localhost

	username: root

	password:



	production:

	adapter: mysql

	database: mywebapp

	host: localhost

	username: root

	password:

	use mywebapp_development;



	DROP TABLE IF EXISTS 'people';

	CREATE TABLE 'people' (

	'id' INT(11) NOT NULL AUTO_INCREMENT,

	'name' VARCHAR(255),

	'email' VARCHAR(255),

	PRIMARY KEY (id)

	) ENGINE=InnoDB;

	$ ./script/generate model Person

	exists app/models/

	exists test/unit/

	exists test/fixtures/

	create app/models/person.rb

	create test/unit/person_test.rb

	create test/fixtures/people.yml

	class Order < ActiveRecord::Base

	  has_many :line_items

	end

	Rails::Initializer.run do |config|

	  config.active_record.pluralize_table_names = false

	end

	use mywebapp_development;

	DROP TABLE IF EXISTS 'users';

	CREATE TABLE 'users' (

	  'id' INT(11) NOT NULL AUTO_INCREMENT,

	  'username' VARCHAR(255) NOT NULL,

	  'password' VARCHAR(40) NOT NULL,

	  PRIMARY KEY ('id')

	);

	$ ./script/generate model User

	      exists app/models/

	      exists test/unit/

	      exists test/fixtures/

          create app/models/user.rb

	      create test/unit/user_test.rb

	      create test/fixtures/users.yml

	class User < ActiveRecord::Base

	  validates_uniqueness_of :username

	  validates_confirmation_of :password, :on => :create

	  validates_length_of :password, :within => 5..40



	  # If a user matching the credentials is found, returns the User object.

	  # If no matching user is found, returns nil.

	  def self.authenticate(user_info)

	    find_by_username_and_password(user_info[:username],

	                                  user_info[:password])

	  end

	end

	use mywebapp_development;

	DROP TABLE IF EXISTS 'users';

	CREATE TABLE 'users' (

	  'id' INT(11) NOT NULL AUTO_INCREMENT,

	  'username' VARCHAR(255) NOT NULL,

	  'hashed_password' VARCHAR(40) NOT NULL,

	  PRIMARY KEY (id)

	);

	require 'sha1'

	

	class User < ActiveRecord::Base

	  attr_accessor :password

	  attr_protected :hashed_password

	  validates_uniqueness_of :username

	  validates_confirmation_of : 

password,

	    :if => lambda { |user| user.new_record? or not user.password.blank? }

	  validates_length_of :password, :within => 5..40,

	    :if => lambda { |user| user.new_record? or not user.password.blank? }



	  def self.hashed(str)

	    SHA1.new(str).to_s

	  end



	  # If a user matching the credentials is found, returns the User object.

	  # If no matching user is found, returns nil.

	  def self.authenticate(user_info)

	    user = find_by_username(user_info[:username])

	    if user && user.hashed_password == hashed(user_info[:password])

	      return user

	    end

	  end



	  private

	  before_save :update_password



	  # Updates the hashed_password if a plain password was provided.

	  def update_password

	    if not password.blank?

	      self.hashed_password = self.class.hashed(password)

	    end

	  end

	end

	<%= @data %>

	<%=h @data %>

	<!-- index.rhtml -->

	<script lang="javascript">

	var text = "<%= escape_javascript @javascript_alert_text %>";

	alert(text);

	</script>

	class IndexController < ApplicationController

	  def index

	    session[:first_time] ||= Time.now

	  end

	end

	<!-- index.rhtml -->

	You first visited this site on <%= session[:first_time] %>.



	That was <%= time_ago_in_words session[:first_time] %> ago.