Notes

Use Hash if would like to search

Cancel the new line

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

kind_of?, which will return true if the object is an instance of DocumentIdentifier or a subclass of DocumentIdentifier
include module, inject a super class to the object
When you tack a block onto the end of a method call, Ruby will package up the block as sort of a secret argument and (behind the scenes) passes this secret argument to the method. Inside the method you can detect whether your caller has actually passed in a block with the block_given? method and fire off the block (if there is one) with yield
```
def each_word
  words.each { |word| yield( word ) }
end
```
Enumerable also contributes the each_cons method to your class. The each_cons method takes an integer and a block, and will repeatedly call the block, each time passing in an array of consecutive elements from the collection.

Benefits for block: execute around

def with_logging(description)
  begin
    @logger.debug( "Starting #{description}" )
    yield
    @logger.debug( "Completed #{description}" )
  rescue
    @logger.error( "#{description} failed!!")
    raise
  end
end

Code blocks drag along the scope in which they were created wherever they go. In the last example, this means that @doc object is automatically visible inside the code block?no need to pass it down as an argument.
Proc vs. Lambda
1. Proc.new object is very forgiving of the number of arguments passed to its call method.
2. a Proc.new block executes an explicit return, Ruby will try to return not just from the block but from the method that created the block. While a return from a lambda wrapped block will simply return from the block and no further

inherited, will get called just after each subclass is define

def self.included( host_class )
  host_class.extend( ClassMethods )
end

at_exit is last in / first out
$! is a global variable that Ruby sets to the last exception raised
If you have many different ways that you might create an object, a set of wellnamed class methods is generally clearer than making the user supply all sorts of clever arguments to the new method
Including modules into the singleton class is a common enough task that Ruby has a special shortcut for it in the form of extend
```
class Document
  extend Finders
  # Most of the class omitted...
end
```
Execute around with a block. All of the variables that are visible just before the opening do or { are still visible inside the code block.
A good rule of thumb is that the only arguments you should pass from the application into an execute around method are those that the execute around method itself, not the block.

Compose methods

class TextCompressor
  attr_reader :unique, :index
  def initialize( text )
    @unique = []
    @index = []
    add_text( text )
  end

  def add_text( text )
    words = text.split
    words.each { |word| add_word( word ) }
  end

  def add_word( word )
    i = unique_index_of( word ) || add_unique_word( word )
    @index << i
  end

  def unique_index_of( word )
    @unique.index(word)
  end

  def add_unique_word( word )
    @unique << word
    unique.size - 1
  end
end

First, each method should do a single thing.
Each method needs to operate at a single conceptual level: Simply put, don’t mix high-level logic with the nitty-gritty details.
Finally, each method needs to have a name that reflects its purpose.

alias_method actually copies a method implementation, giving it a new name along the way.

class String
  alias_method :old_addition, :+
  def +( other )
    if other.kind_of? Document
      new_content = self + other.content
      return Document.new(other.title, other.author, new_content)
    end
    old_addition(other)
  end
end

__FILE__ is supplied via the magic of Ruby and is always set to the path of the source file of the current class
the class_eval method takes a string and evaluates it as if it were code that appeared in the class body
Pass instance_eval a block and, just like call, it will execute the block. The difference is that instance_eval changes the value of self as it executes the block. self is the receiver of the block

Eloquent Ruby Note

Notes