Add Arrays chapter and Creating Arrays unit

Author: paulgoetze

4_Arrays/1_Creating_Arrays/solution.rb

@@ -0,0 +1,3 @@
+# e.g.:
+objects = [2.75, true, []]
+question_marks = Array.new(3, '?')

4_Arrays/1_Creating_Arrays/solution_spec.rb

@@ -0,0 +1,93 @@
+require 'rspec'
+require 'rspec/expectations'
+require 'code_breaker'
+
+VARIABLES = [:objects, :question_marks].freeze
+
+def code_lines
+  %q{[['solution::code']]}
+end
+
+def statements
+  @statements ||= Array(CodeBreaker.parse(code_lines))
+end
+
+def assignment?(statement)
+  statement.is_a?(Hash) && statement.keys.first == :lvasgn
+end
+
+def brackets_statement
+  @brackests_statement ||= statements.select do |statement|
+    assignment?(statement) && statement[:lvasgn].first == VARIABLES.first
+  end
+end
+
+def new_statement
+  @new_statement ||= statements.select do |statement|
+    assignment?(statement) && statement[:lvasgn].first == VARIABLES.last
+  end
+end
+
+def array_assigned?(variable)
+  !!defined?(variable) && variable.is_a?(Array)
+end
+
+def array_defined_with_new?(variable, statement)
+  array_assigned?(variable) &&
+  statement.first[:lvasgn][1][0..1] == [{ const: :Array }, :new]
+end
+
+describe 'Your code' do
+  [['solution::code']]
+
+  VARIABLES.each do |name|
+    it "defines a variable with name \"#{name}\"" do
+      expect(local_variables.include?(name)).to be true
+    end
+
+    if local_variables.include?(name)
+      it "assigns an Array to the variable \"#{name}\"" do
+        expect(eval(name.to_s)).to be_an Array
+      end
+    end
+  end
+
+  if (local_variables & VARIABLES).sort == VARIABLES.sort
+    describe 'assings an Array to "objects" which' do
+      it 'is created by using []' do
+        expect(array_assigned?(objects)).to be true
+        expect(brackets_statement.first[:lvasgn].last.keys.first).to eq :array
+      end
+
+      if array_assigned?(objects)
+        before { @values = brackets_statement.first[:lvasgn].last[:array] }
+
+        it 'holds a Float' do
+          expect(@values.include?(Float)).to be true
+        end
+
+        it 'holdd a Boolean' do
+          included = @values.include?(TrueClass) || @values.include?(FalseClass)
+          expect(included).to be true
+        end
+
+        it 'holds an empty Array' do
+          empty_array = { array: [] }
+          expect(@values.include?(empty_array)).to be true
+        end
+      end
+    end
+
+    describe 'assings an Array to "question_marks" which' do
+      it 'is created by using #new' do
+        expect(array_defined_with_new?(question_marks, new_statement)).to be true
+      end
+
+      if array_defined_with_new?(question_marks, new_statement)
+        it 'holds three times "?"' do
+          expect(question_marks).to eq ['?'] * 3
+        end
+      end
+    end
+  end
+end

4_Arrays/1_Creating_Arrays/task.md

@@ -0,0 +1,87 @@
+# Creating Arrays
+
+---
+
+*You will learn:*
+- what an Array is
+- what you can store in an Array
+- how to create Arrays
+
+---
+
+An Array is a *collection of objects*.
+
+This collection is *ordered*, which means that each object in an Array has a fixed
+place assigned, a so called *index*.
+The index is defined by an integer starting with 0: The first object in the Array
+has the index 0, the second has the index 1, etc.
+
+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:
+An Array can hold all kinds of different objects (e.g. Strings, and Numbers) at the same time.
+
+Let‘s create some Arrays!
+
+## Creating an Array with []
+
+Arrays can be created in different ways.
+The shortest is surrounding a comma-separated list of objects with square brackets:
+
+`  [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:
+
+`  numbers = [1, 2, 3]`
+`  numbers.class`        *# => Array*
+
+you will get `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:
+
+`  Array[1, 2, 3]`       *# => [1, 2, 3]*
+
+## 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.
+
+If you call `new` without any parameter it will create an empty Array:
+
+`  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]
+
+If you pass an Array as first parameter it will return the defined Array:
+
+`  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']]
+
+
+Another way of creating an Array is calling `Array()` with 1 parameter:
+
+`  Array('banana')`      * # => ["banana"]*
+
+This will create a new Array with only the given value and is the same as calling `['banana']`.
+
+---
+
+Assign an Array to a variable *objects* by using the square brackets syntax for creating the Array.
+The Array should have 3 elements: a Float, a Boolean, and an empty Array.
+
+Create an Array that holds 3 times the String *'?'* by using the `new` method.
+Assign the Array to a variable *question_marks*.
+
+---