week #2 diagnostic

 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"`. 
```ruby
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 
  
  def 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?
```ruby
given = [1,2,3,4,5]
given_doubled = []

given_doubled << given * 2

odd = [1,2,3,4,5].find_all {|num| num.odd}
```
4.  Give the command to create a new Git repository in a directory on your machine 
git init 

### 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 is_tasty?
end 

test_if_the_pizza_is_tasty
class Pizza = Pizza.new
assert new_pizza.is_tasty

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 style 
  pizza = Pizza.new
  list = ["supreme", mediterrainean", "chesse"]
  
  assert list.contains?(pizza.style)
  
  or you could use assert_includes list, pizza.style
  
6.  Give the Git commands needed to *stage* and then *commit* a set of changes to a file
```
git add file.rb
git commit -m "itital commit"
git push

```

### 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 initialize90
  @attitutde = "cheerful"
  
  def attitude_chance(new_emotion)
  attitude = new_emotion
  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.

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:

```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:

```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 assignemtns = []
students = [s1,s2,s3]

students.each do |student|
 all assigments << student.assignemts
 end
 
 all_assignemts,join(', ')

class Student
 attr_reader :assignments
 def initialize
  @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)

"x = 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.
```ruby
File.open("~/Documents/pizza.txt", "r").each_line do |line|
puts line
end

```


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.

File.open("~/Documents/pizza.txt", "r").each_line do |line|

file.each line do |num|
puts line
num_lines += 1
end

File.write("~/Documents/pizza.txt", num_lines)


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
*  A Corgi can be assigned a name
*  A Corgi can be asked for its name
*  A Corgi can be asked for its posture, which should default to "standing"
*  A Corgi can be asked to lie down, which should change its posture to "laying"