Update ruby.html.markdown

- Remove special characters
- Unify style and grammar
- Fix typos, etc.

1 files changed, 120 insertions, 126 deletions

diff --git a/ruby.html.markdown b/ruby.html.markdown
index 51f220e3..2f4d0934 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -16,19 +16,20 @@ contributors:
   - ["Persa Zula", "http://persazula.com"]
   - ["Jake Faris", "https://github.com/farisj"]
   - ["Corey Ward", "https://github.com/coreyward"]
+  - ["Jannik Siebert", "https://github.com/janniks"]
 ---
 
 ```ruby
 # This is a comment
 
 # In Ruby, (almost) everything is an object.
-# This includes numbers…
+# This includes numbers...
 3.class #=> Integer
 
-# …strings…
+# ...and strings...
 "Hello".class #=> String
 
-# …even methods!
+# ...and even methods!
 "Hello".method(:class).class #=> Method
 
 # Some basic arithmetic
@@ -67,7 +68,7 @@ false.class #=> FalseClass
 1 != 1 #=> false
 2 != 1 #=> true
 
-# apart from false itself, nil is the only other 'falsey' value
+# Apart from false itself, nil is the only other 'falsey' value
 
 !!nil   #=> false
 !!false #=> false
@@ -111,33 +112,33 @@ placeholder = 'use string interpolation'
 'hello ' + 3.to_s #=> "hello 3"
 "hello #{3}" #=> "hello 3"
 
-# Combine strings and operators
+# ...or combine strings and operators
 'hello ' * 3 #=> "hello hello hello "
 
-# Append to string
+# ...or append to string
 'hello' << ' world' #=> "hello world"
 
-# print to the output with a newline at the end
+# You can print to the output with a newline at the end
 puts "I'm printing!"
 #=> I'm printing!
 #=> nil
 
-# print to the output without a newline
+# ...or print to the output without a newline
 print "I'm printing!"
-#=> I'm printing! => nil
+#=> "I'm printing!" => nil
 
 # Variables
 x = 25 #=> 25
 x #=> 25
 
-# Note that assignment returns the value assigned
-# This means you can do multiple assignment:
+# Note that assignment returns the value assigned.
+# This means you can do multiple assignment.
 
 x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# By convention, use snake_case for variable names
+# By convention, use snake_case for variable names.
 snake_case = true
 
 # Use descriptive variable names
@@ -146,7 +147,7 @@ m = '/bad/name/'
 
 # Symbols are immutable, reusable constants represented internally by an
 # integer value. They're often used instead of strings to efficiently convey
-# specific, meaningful values
+# specific, meaningful values.
 
 :pending.class #=> Symbol
 
@@ -158,82 +159,82 @@ status == 'pending' #=> false
 
 status == :approved #=> false
 
-# Strings can be converted into symbols and vice versa:
-
+# Strings can be converted into symbols and vice versa.
 status.to_s #=> "pending"
 "argon".to_sym #=> :argon
 
 # Arrays
 
-# This is an array
+# This is an array.
 array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
-# Arrays can contain different types of items
-
+# Arrays can contain different types of items.
 [1, 'hello', false] #=> [1, "hello", false]
 
-# Arrays can be indexed
-# From the front
+# Arrays can be indexed.
+# From the front...
 array[0] #=> 1
 array.first #=> 1
 array[12] #=> nil
 
-# Like arithmetic, [var] access
-# is just syntactic sugar
-# for calling a method [] on an object
-array.[] 0 #=> 1
-array.[] 12 #=> nil
-
-# From the end
+# ...or from the back...
 array[-1] #=> 5
 array.last #=> 5
 
-# With a start index and length
+# ...or with a start index and length...
 array[2, 3] #=> [3, 4, 5]
 
-# Reverse an Array
+# ...or with a range...
+array[1..3] #=> [2, 3, 4]
+
+# You can reverse an Array.
 a = [1,2,3]
 a.reverse! #=> [3,2,1]
 
-# Or with a range
-array[1..3] #=> [2, 3, 4]
+# Like arithmetic, [var] access is just syntactic sugar
+# for calling a method '[]' on an object.
+array.[] 0 #=> 1
+array.[] 12 #=> nil
 
-# Add to an array like this
+# You can add to an array...
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 # Or like this
 array.push(6) #=> [1, 2, 3, 4, 5, 6]
 
-# Check if an item exists in an array
+# ...and check if an item exists in an array
 array.include?(1) #=> true
 
 # Hashes are Ruby's primary dictionary with key/value pairs.
-# Hashes are denoted with curly braces:
+# Hashes are denoted with curly braces.
 hash = { 'color' => 'green', 'number' => 5 }
 
 hash.keys #=> ['color', 'number']
 
-# Hashes can be quickly looked up by key:
-hash['color'] #=> 'green'
+# Hashes can be quickly looked up by key.
+hash['color'] #=> "green"
 hash['number'] #=> 5
 
-# Asking a hash for a key that doesn't exist returns nil:
+# Asking a hash for a key that doesn't exist returns nil.
 hash['nothing here'] #=> nil
 
-# When using symbols for keys in a hash, you can use this alternate syntax:
+# When using symbols for keys in a hash, you can use an alternate syntax.
 
-new_hash = { defcon: 3, action: true }
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
 
-new_hash.keys #=> [:defcon, :action]
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
 
 # Check existence of keys and values in hash
-new_hash.key?(:defcon) #=> true
-new_hash.value?(3) #=> true
+hash.key?(:defcon) #=> true
+hash.value?(3) #=> true
 
-# Tip: Both Arrays and Hashes are Enumerable
-# They share a lot of useful methods such as each, map, count, and more
+# Tip: Both Arrays and Hashes are Enumerable!
+# They share a lot of useful methods such as each, map, count, and more.
 
 # Control structures
 
+# Conditionals
 if true
   'if statement'
 elsif false
@@ -242,28 +243,26 @@ else
   'else, also optional'
 end
 
-
+# Loops
 # In Ruby, traditional `for` loops aren't very common. Instead, these 
-# basic loops are implemented using enumerable, which hinges on `each`:
-
+# basic loops are implemented using enumerable, which hinges on `each`.
 (1..5).each do |counter|
   puts "iteration #{counter}"
 end
 
-# Which is roughly equivalent to this, which is unusual to see in Ruby:
-
+# Which is roughly equivalent to the following, which is unusual to see in Ruby.
 for counter in 1..5
   puts "iteration #{counter}"
 end
 
-# The `do |variable| ... end` construct above is called a “block”. Blocks are similar
+# The `do |variable| ... end` construct above is called a 'block'. Blocks are similar
 # to lambdas, anonymous functions or closures in other programming languages. They can
-# be passed around as objects, called, or attached as methods. 
+# be passed around as objects, called, or attached as methods.
 #
-# The "each" method of a range runs the block once for each element of the range.
+# The 'each' method of a range runs the block once for each element of the range.
 # The block is passed a counter as a parameter.
 
-# You can also surround blocks in curly brackets:
+# You can also surround blocks in curly brackets.
 (1..5).each { |counter| puts "iteration #{counter}" }
 
 # The contents of data structures can also be iterated using each.
@@ -274,8 +273,8 @@ hash.each do |key, value|
   puts "#{key} is #{value}"
 end
 
-# If you still need an index you can use "each_with_index" and define an index
-# variable
+# If you still need an index you can use 'each_with_index' and define an index
+# variable.
 array.each_with_index do |element, index|
   puts "#{element} is number #{index} in the array"
 end
@@ -291,9 +290,9 @@ end
 #=> iteration 4
 #=> iteration 5
 
-# There are a bunch of other helpful looping functions in Ruby,
-# for example "map", "reduce", "inject", the list goes on. Map,
-# for instance, takes the array it's looping over, does something
+# There are a bunch of other helpful looping functions in Ruby.
+# For example: 'map', 'reduce', 'inject', the list goes on.
+# Map, for instance, takes the array it's looping over, does something
 # to it as defined in your block, and returns an entirely new array.
 array = [1,2,3,4,5]
 doubled = array.map do |element|
@@ -304,6 +303,7 @@ puts doubled
 puts array
 #=> [1,2,3,4,5]
 
+# Case construct
 grade = 'B'
 
 case grade
@@ -322,7 +322,7 @@ else
 end
 #=> "Better luck next time"
 
-# cases can also use ranges
+# Cases can also use ranges
 grade = 82
 case grade
 when 90..100
@@ -334,9 +334,9 @@ else
 end
 #=> "OK job"
 
-# exception handling:
+# Exception handling
 begin
-  # code here that might raise an exception
+  # Code here that might raise an exception
   raise NoMemoryError, 'You ran out of memory.'
 rescue NoMemoryError => exception_variable
   puts 'NoMemoryError was raised', exception_variable
@@ -354,10 +354,10 @@ def double(x)
   x * 2
 end
 
-# Methods (and blocks) implicitly return the value of the last statement
+# Methods (and blocks) implicitly return the value of the last statement.
 double(2) #=> 4
 
-# Parentheses are optional where the interpretation is unambiguous
+# Parentheses are optional where the interpretation is unambiguous.
 double 3 #=> 6
 
 double double 3 #=> 12
@@ -366,15 +366,14 @@ def sum(x, y)
   x + y
 end
 
-# Method arguments are separated by a comma
+# Method arguments are separated by a comma.
 sum 3, 4 #=> 7
 
 sum sum(3, 4), 5 #=> 12
 
 # yield
-# All methods have an implicit, optional block parameter
-# it can be called with the 'yield' keyword
-
+# All methods have an implicit, optional block parameter.
+# Tt can be called with the 'yield' keyword.
 def surround
   puts '{'
   yield
@@ -383,45 +382,43 @@ end
 
 surround { puts 'hello world' }
 
-# {
-# hello world
-# }
+#=> {
+#=> hello world
+#=> }
 
-
-# Blocks can be converted into a `proc` object, which wraps the block 
+# Blocks can be converted into a 'proc' object, which wraps the block 
 # and allows it to be passed to another method, bound to a different scope,
 # or manipulated otherwise. This is most common in method parameter lists,
-# where you frequently see a trailing `&block` parameter that will accept 
-# the block, if one is given, and convert it to a `Proc`. The naming here is
-# convention; it would work just as well with `&pineapple`:
+# where you frequently see a trailing '&block' parameter that will accept 
+# the block, if one is given, and convert it to a 'Proc'. The naming here is
+# convention; it would work just as well with '&pineapple'.
 def guests(&block)
   block.class #=> Proc
   block.call(4)
 end
 
-# The `call` method on the Proc is similar to calling `yield` when a block is 
-# present. The arguments passed to `call` will be forwarded to the block as arugments:
+# The 'call' method on the Proc is similar to calling 'yield' when a block is 
+# present. The arguments passed to 'call' will be forwarded to the block as arugments.
 
 guests { |n| "You have #{n} guests." }
 # => "You have 4 guests."
 
-# You can pass a list of arguments, which will be converted into an array
-# That's what splat operator ("*") is for
+# You can pass a list of arguments, which will be converted into an array.
+# That's what splat operator ("*") is for.
 def guests(*array)
   array.each { |guest| puts guest }
 end
 
 # Destructuring
 
-# Ruby will automatically destructure arrays on assignment to multiple variables:
+# Ruby will automatically destructure arrays on assignment to multiple variables.
 a, b, c = [1, 2, 3]
 a #=> 1
 b #=> 2
 c #=> 3
 
 # In some cases, you will want to use the splat operator: `*` to prompt destructuring
-# of an array into a list:
-
+# of an array into a list.
 ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
 
 def best(first, second, third)
@@ -430,7 +427,7 @@ end
 
 best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
 
-# The splat operator can also be used in parameters:
+# The splat operator can also be used in parameters.
 def best(first, second, third, *others)
   puts "Winners are #{first}, #{second}, and #{third}."
   puts "There were #{others.count} other participants."
@@ -440,21 +437,23 @@ best *ranked_competitors
 #=> Winners are John, Sally, and Dingus.
 #=> There were 2 other participants.
 
-# By convention, all methods that return booleans end with a question mark
-5.even? # false
-5.odd? # true
+# By convention, all methods that return booleans end with a question mark.
+5.even? #=> false
+5.odd? #=> true
 
-# And if a method ends with an exclamation mark, it does something destructive
+# By convention, if a method name ends with an exclamation mark, it does something destructive
 # like mutate the receiver. Many methods have a ! version to make a change, and
-# a non-! version to just return a new changed version
+# a non-! version to just return a new changed version.
 company_name = "Dunder Mifflin"
 company_name.upcase #=> "DUNDER MIFFLIN"
 company_name #=> "Dunder Mifflin"
-company_name.upcase! # we're mutating company_name this time!
+# We're mutating company_name this time.
+company_name.upcase! #=> "DUNDER MIFFLIN"
 company_name #=> "DUNDER MIFFLIN"
 
+# Classes
 
-# Define a class with the class keyword
+# You can define a class with the 'class' keyword.
 class Human
 
   # A class variable. It is shared by all instances of this class.
@@ -462,7 +461,7 @@ class Human
 
   # Basic initializer
   def initialize(name, age = 0)
-    # Assign the argument to the "name" instance variable for the instance
+    # Assign the argument to the 'name' instance variable for the instance.
     @name = name
     # If no age given, we will fall back to the default in the arguments list.
     @age = age
@@ -478,10 +477,10 @@ class Human
     @name
   end
 
-  # The above functionality can be encapsulated using the attr_accessor method as follows
+  # The above functionality can be encapsulated using the attr_accessor method as follows.
   attr_accessor :name
 
-  # Getter/setter methods can also be created individually like this
+  # Getter/setter methods can also be created individually like this.
   attr_reader :name
   attr_writer :name
 
@@ -496,13 +495,11 @@ class Human
   end
 end
 
-
-# Instantiate a class
+# Instantiating of a class
 jim = Human.new('Jim Halpert')
-
 dwight = Human.new('Dwight K. Schrute')
 
-# Let's call a couple of methods
+# You can call the methods of the generated object.
 jim.species #=> "H. sapiens"
 jim.name #=> "Jim Halpert"
 jim.name = "Jim Halpert II" #=> "Jim Halpert II"
@@ -510,30 +507,30 @@ jim.name #=> "Jim Halpert II"
 dwight.species #=> "H. sapiens"
 dwight.name #=> "Dwight K. Schrute"
 
-# Call the class method
+# Calling of a class method
 Human.say('Hi') #=> "Hi"
 
 # Variable's scopes are defined by the way we name them.
-# Variables that start with $ have global scope
+# Variables that start with $ have global scope.
 $var = "I'm a global var"
 defined? $var #=> "global-variable"
 
-# Variables that start with @ have instance scope
+# Variables that start with @ have instance scope.
 @var = "I'm an instance var"
 defined? @var #=> "instance-variable"
 
-# Variables that start with @@ have class scope
+# Variables that start with @@ have class scope.
 @@var = "I'm a class var"
 defined? @@var #=> "class variable"
 
-# Variables that start with a capital letter are constants
+# Variables that start with a capital letter are constants.
 Var = "I'm a constant"
 defined? Var #=> "constant"
 
-# Class is also an object in ruby. So class can have instance variables.
-# Class variable is shared among the class and all of its descendants.
+# Class is also an object in ruby. So a class can have instance variables.
+# A class variable is shared among the class and all of its descendants.
 
-# base class
+# Base class
 class Human
   @@foo = 0
 
@@ -546,18 +543,17 @@ class Human
   end
 end
 
-# derived class
+# Derived class
 class Worker < Human
 end
 
-Human.foo # 0
-Worker.foo # 0
-
-Human.foo = 2 # 2
-Worker.foo # 2
+Human.foo #=> 0
+Worker.foo #=> 0
 
-# Class instance variable is not shared by the class's descendants.
+Human.foo = 2
+Worker.foo #=> 2
 
+# A class instance variable is not shared by the class's descendants.
 class Human
   @bar = 0
 
@@ -573,8 +569,8 @@ end
 class Doctor < Human
 end
 
-Human.bar # 0
-Doctor.bar # nil
+Human.bar #=> 0
+Doctor.bar #=> nil
 
 module ModuleExample
   def foo
@@ -582,9 +578,8 @@ module ModuleExample
   end
 end
 
-# Including modules binds their methods to the class instances
-# Extending modules binds their methods to the class itself
-
+# Including modules binds their methods to the class instances.
+# Extending modules binds their methods to the class itself.
 class Person
   include ModuleExample
 end
@@ -593,13 +588,12 @@ class Book
   extend ModuleExample
 end
 
-Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
-Person.new.foo # => 'foo'
-Book.foo       # => 'foo'
-Book.new.foo   # => NoMethodError: undefined method `foo'
+Person.foo     #=> NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo #=> "foo"
+Book.foo       #=> "foo"
+Book.new.foo   #=> NoMethodError: undefined method `foo'
 
 # Callbacks are executed when including and extending a module
-
 module ConcernExample
   def self.included(base)
     base.extend(ClassMethods)
@@ -623,10 +617,10 @@ class Something
   include ConcernExample
 end
 
-Something.bar     # => 'bar'
-Something.qux     # => NoMethodError: undefined method `qux'
-Something.new.bar # => NoMethodError: undefined method `bar'
-Something.new.qux # => 'qux'
+Something.bar     #=> "bar"
+Something.qux     #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> "qux"
 ```
 
 ## Additional resources