Builder := Object clone
Builder depth := 0
 
Builder forward := method(
  prefix := "  " repeated(self depth)
  writeln(prefix, "<", call message name, ">")
  self depth = self depth + 1
  call message arguments foreach(arg,
    content := self doMessage(arg)
    if(content type == "Sequence", writeln(prefix, "  ", content))
  )
  self depth := self depth - 1
  writeln(prefix, "</", call message name, ">")
)
 
Builder html(head(title("Programing languages")), body(ul(li("IO"), li("Lua"), li("JavaScript"))))

curlyBrackets := method(
  l := List clone
  call message arguments foreach(arg,
    l append(doMessage(arg))
  )
  return l
)

Fibonacci := Object clone
 
Fibonacci iter := method(n, 
  l := list(1, 1)
  for(i, 2, n, 1, 
    l append(l at(i - 2) + l at(i - 1))
  )
  l at(n - 1)
)
 
Fibonacci rec := method(n,
  if(n < 3, 1, 
    rec(n - 1) + rec(n - 2)
  )
)
 
x := Fibonacci iter(12)
x println
 
y := Fibonacci rec(12)
y println

a := list(list(1, 2, 3))
a append(list(4, 5, 6, 7, 8, 9))
a append(list(10, 11, 12))
a append(list(13, 14, 15, 16, 17, 18, 19, 20))
 
total := 0
 
for(i, 0, a size - 1,
  b := a at(i)
  for(j, 0, b size - 1,
    n := b at(j)
    total = (total + n)
  )
)
 
total println

a := list(1, 2, 3, 4, 5)
b := list(1, "hello")
 
List myAverage := method(
  total := 0
  for(i, 0, self size -1,
    n := self at(i)
    if (n type != "Number",
      Exception raise("An item in the list is not a Number"),
      total = total + n
    )
  )
  total / self size
)
 
a myAverage println
b myAverage println

Matrix := Object clone
 
Matrix list := nil
 
Matrix dim := method(x, y,
  self list := List clone
  for(i, 0, x - 1,
    l := List clone
    for(j, 0, y - 1, l append(nil))
    self list append(l)
  )
)
 
Matrix set := method(x, y, value,
  self list at(x) atPut(y, value)
)
 
Matrix get := method(x, y,
  self list at(x) at(y)
)
 
matrix := Matrix clone
matrix dim(4, 2)
 
matrix set(3, 1, "Hello")
matrix set(1, 1, "World")
 
matrix get(3, 1) println
matrix get(1, 1) println

Matrix transpose := method(
  x := self list at(0) size
  y := self list size
  m := Matrix clone
  m dim(x, y)
  for(i, 0, x - 1,
    for(j, 0, y - 1,
      m set(i, j, self get(j, i))
    )
  )
  m
)
 
new_matrix := matrix transpose
 
(matrix get(3, 1) == new_matrix get(1, 3)) println

Matrix := Object clone
 
Matrix list := nil
 
Matrix dim := method(x, y,
  self list := List clone setSize(x)
  for(i, 0, x - 1,
    self list atPut(i, List clone setSize(y))
  )
)
 
Matrix set := method(x, y, value,
  self list at(x) atPut(y, value)
)
 
Matrix get := method(x, y,
  self list at(x) at(y)
)
 
Matrix transpose := method(
  x := self list at(0) size
  y := self list size
  m := Matrix clone
  m dim(x, y)
  for(i, 0, x - 1,
    for(j, 0, y - 1,
      m set(i, j, self get(j, i))
    )
  )
  return m
)
 
Matrix asString := method(
  s := ""
  self list foreach(e,
    s := s asMutable appendSeq(e join(",")) asMutable appendSeq("\n")
  )
)
 
Matrix saveTo := method(file,
  f := File with(file) remove openForUpdating
  self list foreach(i, e,
    f write(e join(",")) write("\n")
  )
  f close
)
 
Matrix loadFrom := method(file,
  l := List clone
  f := File with(file) openForReading
  f readLines foreach(e,
    l append(e splitNoEmpties(","))
  )
  f close
  m := Matrix clone
  m dim(l size, l at(0) size)
  l foreach(i, e,
    e foreach(j, f,
      m set(i, j, f)
    )
  )
  m
)
 
/* Tests */
matrix saveTo("matrix.txt")
new_matrix saveTo("new_matrix.txt")
 
matrix := Matrix loadFrom("matrix.txt")
new_matrix := Matrix loadFrom("new_matrix.txt")
 
matrix println
new_matrix println

//Not really random, but will suffice for now
n := Date now second * 1000 % 100
 
input := File standardInput();
 
for(i, 1, 10,
  guess := input readLine asNumber
 
  if (guess < n, "Hotter" println)
  if (guess > n, "Colder" println)
  if (guess == n,
    "Well done!" println
    break
  )  
)

module ActsAsCsv
 
  def self.included(base)
    base.extend ClassMethods
  end
 
  module ClassMethods
    def acts_as_csv
      include InstanceMethods
    end
  end
 
  module InstanceMethods
 
    def read
      @csv_contents = []
      filename = self.class.to_s.downcase + '.csv'
      file = File.new(filename)
      @headers = file.gets.chomp.split(', ')
 
      file.each do |row|
        @csv_contents << row.chomp.split(', ')
      end
    end
 
    attr_accessor :headers, :csv_contents
 
    def initialize
      read 
    end
 
    def each(&block)
      @csv_contents.each { |line| block.call CsvRow.new(@headers, line) }
    end
 
  end
 
end
 
class RubyCsv  # no inheritance! You can mix it in
  include ActsAsCsv
  acts_as_csv
end
 
class CsvRow
  attr_accessor :headings, :values
 
  def initialize(headings, values)
    @headings = headings
    @values = Hash[headings.zip(values).map { |e| [e[0], e[1]] }]
  end
 
  def method_missing(name, *args)
    col = name.to_s
    @values[col]
  end
end
 
csv = RubyCsv.new
csv.each { |row| puts row.two }

#File IO without block
#f = File.new("testfile", "r")
#f.close
 
#File IO with block, implicit call to f.close
#File.open("testfile", "r") do |aFile| end
 
#Hash to array
h = { 1 => 2, "cat" => "tom" }
a = h.to_a
 
#Array to hash
a = (1..10).to_a
h = Hash[a.map { |i| [i, i * 2] } ]
 
#Iterate through a hash
h.each { |i| puts "#{i[0]} : #{i[1]}" }
 
#Use array as stack
a.push 19
a.pop
 
#Arrays can be used as: stacks, sets, queues, dequeues, and fifos

#Using each (interesting fact: there is a closure on a here)
a.each { |i| if i % 4 == 0 then puts "#{a[i-4..i-1]}" end }
 
#Using each_slice 
a.each_slice(4) { |s| puts "#{s}" }

#Initial code from the book
class Tree
  attr_accessor :children, :node_name
 
  def initialize(name, children=[])
    @children = children
    @node_name = name
  end
 
  def visit_all(&block)
    visit &block
    @children.each { |c| c.visit_all &block }
  end
 
  def visit(&block)
    block.call self
  end
end
 
t = Tree.new("Ruby", [Tree.new("Gem")])
t.visit_all { |t| puts "#{t.node_name}" }

Tree.new({ 'grandpa' => { 'dad' => { 'child 1' => {}, 'child 2' => {} }, 'uncle' => { 'child 3' => {}, 'child 4' => {} } } })

class Tree
  attr_accessor :children, :node_name
 
  def initialize(structure)
    structure.each do
      |key, value|
      @node_name = key
      @children = value.to_a.map { |e| Tree.new({ e[0] => e[1] }) }
    end
  end
 
  def visit_all(&block)
    visit &block
    @children.each { |c| c.visit_all &block }
  end
 
  def visit(&block)
    block.call self
  end
end
 
t = Tree.new({ 'grandpa' => { 'dad' => { 'child 1' => {}, 'child 2' => {} }, 'uncle' => { 'child 3' => {}, 'child 4' => {} } } })
t.visit_all { |t| puts "#{t.node_name}" }

regex = Regexp.new('sit amet')
ln = 0
 
IO.foreach("TestGrep.txt") do |line|
  ln = ln + 1
  puts "#{ln}: #{line}" if regex.match(line)
end

(1..10).each { |i| puts "This is sentence number #{i}" }

max = 1024
 
guess = -1
number = rand(max) + 1
 
puts "Guess a number from 1 to #{max}"
 
until guess == number
  guess = gets.to_i
  puts "Number is greater than #{guess}" if number > guess
  puts "Number is lesser than #{guess}" if number < guess
end
 
puts "Well done!"