• method chaining
  

a.b(c).d(e).f thing.should_receive(:some_method).once.with

• 1 line method definitions
  

def try(*args) puts args; end
try 1,2
=> 1
2 
def try *args puts args; end
try 1, 2, 4
SyntaxError: (irb):15: syntax error, unexpected tIDENTIFIER, expecting ';' or '\n'
def try *args puts args; end;
                  ^
(irb):15: syntax error, unexpected keyword_end, expecting end-of-input
def try *args puts args; end;

task :rake => pre_rake_task do
  something
end
#really means:
task(:rake => pre_rake_task){ something }


#but
task :rake => pre_rake_task {
  something
}
#really means:
task :rake => (pre_rake_task { something })


#solution - brackets
task(:rake => pre_rake_task) {
  something
} 

Gotcha!

puts [1,2,3].map{ |k| k+1 }
2
3
4
=> nil
puts [1,2,3].map do |k| k+1; end
#<Enumerator:0x000000009f9a20>
<0x0000010a06d140 style="font-style: normal; font-variant: normal;">=> nil 
#same as [1,2,3].map() do |k| k+1; end

#turnif !@read_only
 
#into 
unless @read_only 
#this is executed if "@read_only == false/nil"  

#turn
while ! document.is_printed?
  ...
end

#into
until document.printed? 
  ...
end 

• when no to use unless
  

#don't use unless with negations and multiple conditions
unless !person.present? && !company.present?
end

#do
if person.present? && company.present?
end 

#don't use with else
unless person.present?
  puts "Not present"
else
  puts "Present"
end

#do
if person.present?
  puts "Present"
else
  puts "Not present"
end 

fonts = [ 'courier', 'times roman', 'helvetica' ]

for font in fonts
  puts font
end

fonts.each do |font| 
  puts font
end 

• for is an each in disguise
  
• each has a scope
  

• numbers = [1,2,3]numbers.each {|i| zmienna = i; }
  zmienna =>
  NameError: undefined local variable or method `zmienna' for main:Object
  
  for i in numbers
    zmienna = i
  end
  zmienna => 3
  

case title 
when 'War And Peace' 
  puts 'Tolstoy' 
when 'Romeo And Juliet' 
  puts 'Shakespeare' 
else   puts "Don't know" end 

• in Ruby everything returns a value, even case (when no return value, nil is returned)

• for class Object - the same as == - subclasses override it
  
• for class Module - true if an object is an instance of specified class or its decendants (uquivalent to object.is_a? Class)

• Fixnum === 2 #=> true 
  Fixnum.ancestors  => [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject] 
  Integer === 2 #=> true 

• for Range

• (1...10) === 5 => true 

/AB/i === 'ab' => true  

2 === Fixnum #=> false  

• regex
  

case title
when /War And .*/
  puts 'Maybe Tolstoy?'
when /Romeo And .*/
  puts 'Maybe Shakespeare?' end

• class
  

case doc
when Document
  puts "It's a document!"
when String
  puts "It's a string!"end

• only nil and false are treated as false, eveything else is true (also 0)
  

# Broken in a subtle way...
while next_object = get_next_object
  # Do something with the object
end

until (next_object = get_next_object).nil?
  # Do something with the object
end 

• capture value of if
  

ret = if @not_before && @not_before > time
  [false, :expired, "not valid before '#@not_before'"]
elsif @not_after && @not_after < time
  [false, :expired, "not valid after '#@not_after'"]end
 

poem_words = %w{ twinkle little star how I wonder } 
=> ["twinkle", "little", "star", "how", "I", "wonder"]   

def load_font( name, size = 12 )
  # Go font hunting...
end 

• any number of parameters -> splat
  

def echo_all( *args )
  args.each { |arg| puts arg }
end #so no instead of echo_all ["he", "ll", "o"]#you can doecho_all "he", "ll", "o"

• array to hash conversion
  

• array = [[key_1, value_1], [key_2, value_2], ... [key_n, value_n]]
  Hash[*array.flatten]
  #Hash[key1, value1, ...] = { key1 => value1, ... }  

• destructuring assignment
  

• first, second, *rest = [1,2,3,4,5]
  first => 1
  second => 2
  rest => [3,4,5] 

• iterating hash
  

movie = {a: 1, b: 2}movie.each { |key, value| puts "#{key} => #{value}"} a => 1
b => 2
 => {:a=>1, :b=>2}

• find an index
  

["aa", "a", "Aa"].find_index { |word| word.length == 2 && word =~ /aa/ }=> 0

• transform all elements -> map
  

require 'pp'pp ["aa", "a", "Aaa"].map { |word| word.size } =>[2, 1, 3]

• from Ruby 1.9 hashes are ordered!
  

• hey_its_ordered = { first: 'mama', second: 'papa', third: 'baby' }
  hey_its_ordered.each { |entry| pp entry }
  [:first, "mama"]
  [:second, "papa"]
  [:third, "baby"]  

• adding a value -> to the end

• delete all negative values

array.delete_if {|x| x < 0}  

• find - find one item that matches the block

%w[ruby is really nice].find { |item| item.length > 5 } => "really" 

• group_by - groups elements with the block value as hash
  

• double or single (limited interpretation) quotes

• a_string_with_a_quote = 'Say it ain\'t so!'
  double_quoted = "I have a tab: \t and a newline: \n" 

  author = "Ben Bova"
  title = "Mars"
  puts "#{title} is written by #{author}" 

• nesting each other

• str = '"Stop", she said, "I cannot deal with the backslashes." 

• spannig across lines

a_multiline_string = "a multi-line
string"
another_one = %q{another multi-line
string}  

• no newlines

yet_another = %Q{another multi-line string with \
no newline} 

• here document for long multiline string
  

heres_one = <<RANDOM_TEXTof my here document.
And this is the end.
RANDOM _TEXT

' hello'.lstrip => 'hello'
#rstrip

#remove 1 unwanted newline at the end
"It was a dark and stormy night\n".chomp => "It was a dark and stormy night\n".chomp
"hello\n\n\n".chomp => "hello\n\n"

#remove last character
"hello".chop => "hell"

#upcase/downcase
'Hello'.swapcase => 'hELLO' 
#substitute 1 occurance'It is warm outside'.sub( 'warm', 'cold' ) => "It is cold outside"#substitute allputs 'yes yes'.gsub( 'yes', 'no' ) => no no

#break into smaller parts'It was a dark and stormy night'.split => ["It", "was", "a", "dark", "and", "stormy", "night"]
'Bill:Shakespeare:Playwright:Globe'.split( ':' ) => ["Bill", "Shakespeare", "Playwright", "Globe"]

#with regexps="http://www.website.com/dir1/dir2/file.txt"
s.split /:\/\/|\.|\//
=> ["http", "www", "website", "com", "dir1", "dir2", "file", "txt"]


#locate string"It was a dark and stormy night".index( "dark" ) => 9

• string - a collection of lines

"some\n funky\n string\n here".each_line { |l| puts l}
some
 funky
 string
 here  

• strings are mutable
  

• make unmutable
  

s = "omg"
s.freeze
s.frozen? => true
s << "won't work" 
=> RuntimeError: can't modify frozen String
#unfreeze -> make new object
s = "A new string" => "A new string"s.freeze
s += "this will also work"=> "A new stringthis will also work" 

• last character

first_name[-1] 

• . - any single character except newline
  
• \. - to match dot character (period)
  
• [aeiou] - set, any single lowercase vowl
  
• [0-9] - range, single decimal digit
• \d - any digit
• \D - any non-digit
• \w - word character: letter, number, underscore
• \s - any whitespace character (tab, newline, space)
• \S - any non-whitespace character
• | - alternative, ie: AM|PM 
• () - to set pattern off, ie: (AM|PM)

• A* - zero or more A's
  
• [aeiou]* - any number of vowls
  
• .* - any number of any characters
  

• \A - beginning of string
  
• \z - end of string
  
• ^ - begining of string or any newline within string
  
• $ - end of string or any newline
  

• match across lines: /aeiou/m
  

/^Once upon a time.*happily ever after\.$/m 

• similar to strings: 'dog' vs :dog, but not quite the same 
  

• used as flags !
  

• conversion
  

:all.to_s => 'all'
'string'.to_sym => :string 

• use strings for data, use symbols to stand for
  

person = {}
person[:name] = 'russ'
person[:eyes] = 'misty blue'
# A little later...
puts "Name: #{person['name']} Eyes: #{person['eyes']}" 

"str".class => String
"str".class.class => Class1.class => Fixnum #
nil.class => NilClass
false.class => FalseClass -3.class => Fixnum/regex/.class => Regexp:symbol.class => Symbol

• containers for methods
  
• factories for making instances
  

doc = Document.new( 'Ethics', 'Spinoza', 'By that which is...' ) =>

• self - instance that called the method
  

class Document
  ...
  def about_me
    puts "I am #{self}"
    puts "My title is #{self.title}"
    puts "I have #{self.word_count} words"
  end
end 

• calling a method without explicit object reference - defaults to self  

• class Foo
    attr_writer :bar
    def do_something
      bar = 2
    end
  end 

• every class has a superclass, when no superclass is explicitly defined - superclass defaults to Object
  

• method call - find the method in the class, when no method found search in superclass, reapeat until no more superclasses left
  

"lol".class => String
"lol".instance_of? String => true
some_object.to_s => "#<0x00000001e75cb0>"
eval "puts 'hello'" => hello
"lol".public_methods => [:<=>, :==, :===, :eql?, :hash, :casecmp, :+, :*, :%, :[], :[]=, :insert, :length, :size, :bytesize, ....]

class Document
  def initialize
    @name = "Borat"
  end
end
d = Document.new
d.instance_variables => [:@name]  

• methods are public by default

• making private
  

class Document
# Most of the class omitted
private
  # Methods are private starting here
  def word_count
    return words.size 
  end
end 

• private methods are callable from the class that defines them
  

class Document
# Most of the class omitted...
  def word_count
    return words.size
  end
private :word_count
# This method works because self is the right thing,
# the document instance, when you call it.
  def print_word_count
    n = word_count
    puts "The number of words is #{word_count}"
  end
end 

• Any instance of a class can call a protected method on any other instance of the class, so any instance of Document can call word_count on any other instance of Document (including subclasses)
  

• private and protected aren't widely used: Ruby standard library 20 000 lines of code, 1000 private, 50 protected
  

• calling a private method outside of class:
  

n = doc.send( :word_count )

• private, protected
  
• attr_accessor, attr_writer, attr_reader
  
• require
  

• assigning a value
  
• if statement
  
• while