# Week 2 Diagnostic

This exercise is intended to help you assess your progress with the concepts and techniques we've covered during the week.
For these questions, write a short snippet of code that meets the requirement. In cases where the question mentions a "given" data value, use the variable `given` to refer to it (instead of re-writing the information).
Use single (\`) and triple backticks (\`\`\`) to container code snippets.

1.  Define a class called `PizzaOven` which has a method `cook_pizza` which returns the string `"mmm 'za"`.
  class PizzaOven
    def cook_pizza
      "mmm 'za"
    end
  end

2.  Define a class called `Student` which is instantiated with a "name" value and which has a method `name` that returns this value
  class Student
    attr_reader :name
    def initialize(name)
      @name = name
    end
  end

3.  Given an array of the numbers `[1,2,3,4,5]`, how would you create a new array of all elements doubled? How would you return an array of all odd elements?
  doubled = []
  array.each do |num|
    doubled << num * 2
  end

  array.find_all do |num|
    num.odd?
  end

4.  Give the command to create a new Git repository in a directory on your machine
  git push origin -b url  -or  something along those lines. I still go into github to create the repo and push from command line

### Pizza

5.  Given a hypothetical `Pizza` class which has an instance method `is_tasty?` that always returns true, write a simple Minitest test that tests this behavior.
  def test_its_tasty
    pizza = Pizza.new
    assert pizza.is_tasty?
  end


6.  Suppose the `Pizza` class also has a method `style` which randomly returns one of: `"supreme"`, `"mediterranean"`, or `"cheese"`. Write a test that confirms that the returned pizza style is within this list.
  def test_style_choices
    pizza = Pizza.new
    assert_equal "supreme" || "mediterranean" || "cheese", pizza.style
  end

6.  Give the Git commands needed to *stage* and then *commit* a set of changes to a file
  git add .
  git commit -m "changes"

### Student

7.  Define a `Student` class which, when created, has an `attitude` attribute.
`attitude` should start out with the value "cheerful", and the `Student` class should provide a "reader" method that allows us to access the value of its `attitude`.
  class Student
    attr_reader :attitude
    def initialize(attitude = cheerful)
      @attitude = attitude
    end
  end

8.  Additionally, add an `assign_homework` method to `Student`. When `assigned_homework` is invoked, if the student's `attitude` is `"cheerful"`, it should become `"dubious"`. If the value is currently `"dubious"` it should become `"perturbed"`. If the value is currently `"perturbed"`, it should become `"dazed"`. Assigning homework to a `"dazed"` student has no effect.
  def assign_homework
    attitude = "dazed" if attitude = "perturbed"
    attitude = "perturbed" if attitude = "dubious"
    attitude = "dubious" if attitude = "cheerful"
  end

9.  Building on the `Student` class from the previous example, update the `assign_homework` method to accept an argument. The argument will be a `String` containing a short description of the assignment. For example we might use it like this:
  def assign_homework(description)
    attitude = "dazed" if attitude = "perturbed"
    attitude = "perturbed" if attitude = "dubious"
    attitude = "dubious" if attitude = "cheerful"
  end
```ruby
s = Student.new
s.assign_homework("Write a linked list")
```

Then, add an `assignments` method to `Student`. `assignments` should return a list of all the assignments that have been given, separated by a comma and a space. For example:
  assignments = ""
  def assignments
    assignments += description + ", "
  end
```ruby
s = Student.new
s.attitude
=> "cheerful"
s.assign_homework("write a linked list")
s.attitude
=> "dubious"
s.assign_homework("write a BST")
s.attitude
=> "perturbed"
s.assignments
=> "write a linked list, write a BST"
```

10. Given an array of 3 `Student` instances, generate a new string of *all* of their assignments

For example:

```
s1 = Student.new
s2 = Student.new
s3 = Student.new

s1.assign_homework("linked list")
s1.assign_homework("sorting algos")

s2.assign_homework("write a c compiler")
s2.assign_homework("write a pacman game")

s3.assign_homework("headcount")
s3.assign_homework("sales engine")

students = [s1,s2,s3]

 all_assignments = ""
  students.each do |hw|
    all_assignments += students[hw].assignments + " "
  end

=> "linked list, sorting algos, write a c compiler, write a pacman game, headcount, sales engine"
```

11. What does the following code output?

```ruby
def print_variables(x)
  puts "x: #{x}"
  puts "b: #{b}"
end

def b
  12
end

a = 4
print_variables(a)
```
  "a: 4"
  "b: 12"

12. Working with files: given a text file located at `"~/Documents/pizza.txt"`, write code to read the
file from the filesystem and print _each line_ one at a time.

  new_file = File.open(ARGV[0], "r")
  text = new_file.read
  print text



13. Writing Files: given a text file located at `"~/Documents/pizza.txt"`, write code to read the file from the filesystem, then write a new file at `"~/Documents/line_count.txt"` containing the number of lines in the original file.

  new_file = File.open(ARGV[0], "r")
  text = new_file.read
  print text
  writer = File.open(ARGV[1], "w")
  writer.write(text)


14.  Imagine a simple ruby class designed to represent a Corgi dog. Write a _test_ for each of the following features:

*  A Corgi can be created with no arguments
  def test_it_exisits
    dog = Corgi.new
    assert_instance_of Corgi
  end
*  A Corgi can be assigned a name
  def test_it_has_name
    dog = Corgi.new("Bob")
    assert_equal "Bob", dog.name
  end
*  A Corgi can be asked for its name
  def test_provides_name
    dog = Corgi.new("Ted")
    assert_equal "Ted", dog.name
  end
*  A Corgi can be asked for its posture, which should default to "standing"
  def test_posture
    dog = Corgi.new("Ted", posture = "standing")
    assert_equal "standing", dog.posture
  end
*  A Corgi can be asked to lie down, which should change its posture to "laying"
  def test_dog_lies_down
    dog = Corgi.new("Ted", posture = "standing")
    assert_equal "laying", dog.lie_down
  end