Fix texts for Array units 1-3

Author: paulgoetze

4_Arrays/1_Creating_Arrays/solution_spec.rb

@@ -66,7 +66,7 @@ def array_defined_with_new?(variable, statement)
           expect(@values.include?(Float)).to be true
         end
 
-        it 'holdd a Boolean' do
+        it 'holds a Boolean' do
           included = @values.include?(TrueClass) || @values.include?(FalseClass)
           expect(included).to be true
         end

4_Arrays/1_Creating_Arrays/task.md

@@ -20,7 +20,7 @@ The index can be used to access the objects in an Array. You will learn more
 about using the index in the next unit "Accessing elements".
 
 An Array can hold all kinds of Ruby objects, such as Strings, Numbers, Booleans,
-other Arrays, etc. The objects in an Array don‘t need to be of the same type:
+other Arrays, etc. The objects in an Array don‘t need to be of the same type.
 An Array can hold all kinds of different objects (e.g. Strings, and Numbers) at the same time.
 
 Let‘s create some Arrays!
@@ -32,12 +32,13 @@ The shortest is surrounding a comma-separated list of objects with square bracke
 
 `  [1, 'Mary', true]`    *# => [1, "Mary", true]*
 
-An Array is a Ruby object itself. If you ask for an Array‘s class with the `class` method:
+An Array is a Ruby object itself. If you ask for an Array‘s class with the `class` method
+you will get `Array`:
 
 `  numbers = [1, 2, 3]`
 `  numbers.class`        *# => Array*
 
-you will get `Array`. An Array is an object of type *Array*.
+An Array is an object of type *Array*.
 
 Instead of using `[]` you can also use the the longer way and call the `[]` method
 of the *Array* class:
@@ -46,33 +47,33 @@ of the *Array* class:
 
 ## Creating an Array with #new
 
-Besides using `[]`, you can create an Array by instanciating an Array with the `new` method.
-The `new` method accepts 2 optional parameters: The number of elements, and the element itself.
+Besides using `[]`, you can create an Array by instantiating an Array with the `new` method.
+The `new` method accepts two optional parameters: The number of elements, and the element itself.
 
 If you call `new` without any parameter it will create an empty Array:
 
-`  Array.new`            * # => []*
+`  Array.new`            *# => []*
 
 If you only define the first parameter as an Integer, it will use this Integer to define
 the length of the new Array and will assign *nil* for each element:
 
-`  Array.new(2)`         * # => [nil, nil]
+`  Array.new(2)`         *# => [nil, nil]*
 
 If you pass an Array as first parameter it will return the defined Array:
 
-`  Array.new([1, 2, 3])` * # => [1, 2, 3]*
+`  Array.new([1, 2, 3])` *# => [1, 2, 3]*
 
 The actual interesting case is, if you pass both parameters.
 It will create an array of the length given in the first parameter, with each element
 being the second parameter. Here is an example:
 
-`  Array.new(3, 4.5)`         * # => [4.5, 4.5, 4.5]*
-`  Array.new(2, ['a', 'b'])`  * # => [['a', 'b'], ['a', 'b']]
+`  Array.new(3, 4.5)`         *# => [4.5, 4.5, 4.5]*
+`  Array.new(2, ['a', 'b'])`  *# => [['a', 'b'], ['a', 'b']]*
 
 
-Another way of creating an Array is calling `Array()` with 1 parameter:
+Another way of creating an Array is calling `Array()` with a single parameter:
 
-`  Array('banana')`      * # => ["banana"]*
+`  Array('banana')`      *# => ["banana"]*
 
 This will create a new Array with only the given value and is the same as calling `['banana']`.
 

4_Arrays/2_Accessing_elements/task.md

@@ -3,69 +3,69 @@
 ---
 
 *You will learn:*
-- how to get single elements from an Array
+- how to get a certain element from an Array
 - how to get subsets of elements from an Array
 
 ---
 
 Each element in an Array is associated with a fixed place – its *index*.
-The index is an Integer which allows to access an element in the Array.
+The index is an Integer by which you can access an element in the Array.
 
 The index 0 points to the first element, the index 1 to the second element, etc.
 Negative indexes point to elements backwards from the last element. E.g. -1 points
 to the last element, -2 points to the second last element, and so on.
 
-## Getting a single element from an Array
+## Getting an element from an Array
 
-You can get the object from an Array at an index by using squared brackets:
+You can get the object from an Array at a certain index by using squared brackets:
 
 `  numbers = [2, 4, 9]` *# defining an Array `numbers`*
-`  numbers[0]`          *# => 2
-`  numbers[1]`          *# => 4
-`  numbers[2]`          *# => 9
-`  numbers[-1]`         *# => 9
+`  numbers[0]`          *# => 2*
+`  numbers[1]`          *# => 4*
+`  numbers[2]`          *# => 9*
+`  numbers[-1]`         *# => 9*
 
 If there is no element present for the given index you will get a *nil* value:
 
-`  numbers[3]`          *# => nil
+`  numbers[3]`          *# => nil*
 
 `[]` is just an ordinary method that is defined for an instance of Array.
 
 Another way for getting a single element is using the alias method `at`:
 
-`  numbers.at(0)`       *# => 2
-`  numbers.at(-1)`      *# => 9
-`  numbers.at(3)`       *# => nil
+`  numbers.at(0)`       *# => 2*
+`  numbers.at(-1)`      *# => 9*
+`  numbers.at(3)`       *# => nil*
 
 There are two methods for getting special elements of an Array: `first` and `last`.
-`first` – as you might have guessed – returns the first element (at index 0),
-and `last` returns the last element (at index -1):
+The method `first` – as you might have guessed – returns the first element 
+(at index 0), and `last` returns the last element (at index -1):
 
 `  numbers.first`       *# => 2*
 `  numbers.last`        *# => 9*
 
 ## Getting a subset of elements from an Array
 
-You can also pass 2 parameters to the `[]` method. This allows to select a subarray
+You can also pass two parameters to the `[]` method. This allows to select a subarray
 by defining the index to start at and the number of elements you want to grab, e.g.:
 
-`  numbers[1, 2]`       * # => [4, 9]*
+`  numbers[1, 2]`       *# => [4, 9]*
 
-returns 2 elements starting at index 1. If there are no elements for the given indexes
+returns two elements starting at index 1. If there are no elements for the given indexes
 available, it returns *nil*:
 
-`  numbers[10, 2]`      * # => nil*
+`  numbers[10, 2]`      *# => nil*
 
 Another way to select a subarray from an Array is to pass a *Range* of the wanted
 indexes to `[]`:
 
-`  numbers[1..2]`       * # => [4, 9]
+`  numbers[1..2]`       *# => [4, 9]*
 
 In case the elements are not available for the indexes it will again return *nil*:
 
-`  numbers[5..10]`      * # => nil*
+`  numbers[5..10]`      *# => nil*
 
-For further information about the `[]` method, see (ruby-doc core: Array#[]).
+For more information about the `[]` method, see (ruby-doc core: Array#[]).
 
 ---
 
@@ -76,6 +76,6 @@ Define a variable *first* and assign the first programming language to it.
 
 Define a variable *last* and assign the last programming language to it.
 
-Store the middle 3 programming languages in a variable *some_languages*.
+Store the three middle programming languages in a variable *some_languages*.
 
 ---

4_Arrays/3_Adding_elements/solution_spec.rb

@@ -12,32 +12,30 @@
   end
 
   if local_variables.include?(VARIABLE)
-    it 'defines a variables "baggage" that has all the items' do
-      expect(eval(VARIABLE.to_s)).to eq ITEMS
+    before(:all) do
+      @statements = CodeBreaker.parse( %q{ [['solution::code']] })
     end
 
-    if eval(VARIABLE.to_s) == ITEMS
-      before(:all) do
-        @statements = CodeBreaker.parse( %q{ [['solution::code']] })
-      end
+    it 'uses the unshift method to add "glasses"' do
+      unshift = [{ lvar: VARIABLE }, :unshift, String]
+      expect(@statements.include?(unshift)).to be true
+    end
 
-      it 'uses the unshift method to add "glasses"' do
-        unshift = [{ lvar: VARIABLE }, :unshift, String]
-        expect(@statements.include?(unshift)).to be true
-      end
+    it 'uses the push or << method to add "shoes"' do
+      push = [{ lvar: VARIABLE }, :push, String]
+      arrows = [{ lvar: VARIABLE }, :<<, String]
 
-      it 'uses the push or << method to add "shoes"' do
-        push = [{ lvar: VARIABLE }, :push, String]
-        arrows = [{ lvar: VARIABLE }, :<<, String]
+      includes_code = @statements.include?(push) || @statements.include?(arrows)
+      expect(includes_code).to be true
+    end
 
-        includes_code = @statements.include?(push) || @statements.include?(arrows)
-        expect(includes_code).to be true
-      end
+    it 'uses the insert method to add "trousers" and "socks"' do
+      insert = [{ lvar: VARIABLE }, :insert, Fixnum, String, String]
+      expect(@statements.include?(insert)).to be true
+    end
 
-      it 'uses the insert method to add "trousers" and "socks"' do
-        insert = [{ lvar: VARIABLE }, :insert, Fixnum, String, String]
-        expect(@statements.include?(insert)).to be true
-      end
+    it 'changes your baggage to contain "glasses", "shirt", "trousers", "socks", & "shoes"' do
+      expect(eval(VARIABLE.to_s)).to eq ITEMS
     end
   end
 end

4_Arrays/3_Adding_elements/task.md

@@ -16,14 +16,14 @@ This unit will look into different ways of adding elements to an Array.
 
 ## Adding elements to the end of an Array
 
-An Array instance has several methods for adding elements.
+An Array object has several methods for adding elements.
 If you want to add a *single* element to the end you can use the `<<` method:
 
 `  numbers = [1, 2, 3]`
 `  numbers << 4`              *# => [1, 2, 3, 4]*
 
 You could also write `numbers.<<(4)`, so the missing *.* and *()* are just a bit of
-syntactical sugar.
+syntactic sugar.
 
 A similiar method for adding an element to the end of an Array is `push`:
 
@@ -35,13 +35,14 @@ many elements as you want in a single call:
 
 `  chars.push('d', 'e', 'f')` *# => ['a', 'b', 'c', 'd', 'e', 'f']*
 
-Both `<<` and `push` will modify the given Array directly. If you check the values
-of the variables above after calling the methods on them they will contain the added values:
+Both `<<` and `push` will modify the given Array directly. If you check the values of 
+the variables above after calling the `<<` or `push` methods they will contain the 
+added values:
 
 `  numbers`                   *# => [1, 2, 3, 4] *
 `  chars`                     *# => ['a', 'b', 'c', 'd', 'e', 'f']*
 
-If you want to build a new Array out of an existing one by adding elements, the `+` method
+If you want to build a new Array from an existing one by adding elements, the `+` method
 will help you to combine two Arrays:
 
 `  numbers = [1, 2]`
@@ -56,7 +57,7 @@ The original Array will stay the same:
 ## Adding elements to the beginning of an Array
 
 If you want to add elements to the beginning of an Array instead, you can use the
-`unshift` method which takes 1 or more elements to add as arguments:
+`unshift` method which takes one or more elements to add as arguments:
 
 `  numbers = [1, 2]`
 `  numbers.unshift(0)`        *# => [0, 1, 2]*
@@ -81,7 +82,7 @@ all the values now:
 
 `  vegetables` *# => ['potato', 'cucumber', 'cauliflower', 'pepper']
 
-Now that you have learned a couple of possibilities for adding elements to an Array
+Now that you have learned various methods for adding elements to an Array,
 let’s summarize them again:
 
 `  <<`      *adds element at end           modifies the original Array*