Adding RailsBridge Boston 1.2014 ruby workshop mods

Modifications include:
* fleshing out all the sites/ruby workshop content -- janetriley, mxie, dpickett
* Adding the 'challenge' tag to the dsl -- dpickett

Author: janetriley

lib/step.rb

@@ -58,6 +58,7 @@ def insert file
     overview:"Overview",
     discussion:"Discussion Items",
     hints:"Hints",
+    challenge:"Challenge(s)",
     tools_and_references:"Tools and References",
     requirements:"Requirements to advance",
   }

public/css/step.css

@@ -141,6 +141,7 @@ table.bordered tr {
 .explanation > h1:before,
 .deploying > h1:before,
 .overview > h1:before,
+.challenge > h1:before,
 .further-reading > h1:before {
   content: "\00a0";
   display: inline-block;

sites/en/ruby/booleans.step

@@ -0,0 +1,117 @@
+message "George Boole was an English mathematician who specialized in logic,
+especially logic rules involving true and false.  The Boolean datatype
+is named in his honor.
+
+In code, as in life, we base a lot of decisions on whether something is true or
+false. *\"If it is raining, then I will bring an umbrella; otherwise I will wear
+sunglasses.\"*  In the conditionals section we'll make decisions. First we need to look at true and false."
+
+goals do
+  goal "Meet True and False"
+  goal "Compare numbers and strings"
+  goal "Evaluate 'and', 'or', and 'not' logic"
+  goal "Understand methods ending with question marks (predicates)"
+end
+
+
+step do
+  message 'Here are some expressions that return `true` or `false`:'
+  irb <<-IRB
+15 < 5
+15 > 5
+15 >= 5
+10 == 12
+  IRB
+end
+
+
+step do
+  message 'Notice we use a double equals sign to check if things are equal.  It\'s a common mistake to use a single equals sign.'
+  irb <<-IRB
+a = 'apple'
+b = 'banana'
+a == b
+puts a + b
+a = b
+puts a + b
+IRB
+   message "Surprise!"
+end
+
+step do
+  message "For 'not equals', try these:"
+  irb <<-IRB
+a = 'apple'
+b = 'banana'
+a != b
+IRB
+  message "The exclamation point means **the opposite of**"
+  irb <<-IRB
+!true
+!false
+!(a == b)
+IRB
+  message "In `!(a == b)`,  Ruby first evaluated `a == b`, then gave the opposite."
+  message "It also means **not true** .  In conditionals, we'll see things like
+
+
+        if not sunny
+            puts \"Bring an umbrella!\"
+
+We can also say
+
+        if sunny == false
+            puts \"Bring an umbrella!\"
+but \"if not sunny\" is a little more natural sounding.  It's also a little safer
+- that double equals is easy to mistype as a single equals."
+end
+
+step do
+    message "We can check more than one condition with `and` and `or` . `&&` and `||` (two pipes) is another notation for `and` and `or`."
+    message "We do something like this when we Google for 'microsoft and cambridge and not seattle'"
+irb <<-IRB
+# First let's define variables:
+yes = true
+no = false
+# Now experiment.  Boolean rule 1:  AND means everything must be true. 
+# true and true are true
+yes and yes
+yes && yes
+# true and false fail the test - AND means everything must be true
+yes and no
+no and yes
+no and no
+# Boolean rule 2: OR says at least one must be true. 
+yes or no
+yes || no
+yes or yes
+IRB
+end
+
+
+step do
+  message 'By convention, methods in Ruby that return booleans end with a question mark.'
+  irb <<-IRB
+'sandwich'.end_with?('h')
+'sandwich'.end_with?('z')
+[1,2,3].include?(2)
+[1,2,3].include?(9)
+'is my string'.empty?
+''.empty?
+'is this nil'.nil?
+nil.nil?
+  IRB
+end
+
+
+explanation do
+    message "In code we ask a lot of questions. Boolean logic gives us tools to express the questions. "
+end
+
+further_reading do
+    message "Some languages offer wiggle room about what evaluates to true or false. Ruby has very little. See [What's Truthy and Falsey in Ruby?](https://gist.github.com/jfarmer/2647362)"
+    message "[What's Truthy and Falsey in Ruby?](https://gist.github.com/jfarmer/2647362) has a more detailed walkthrough of booleans."
+    message "Ruby documentation for [true](http://www.ruby-doc.org/core-2.1.0/TrueClass.html) and [false]](http://www.ruby-doc.org/core-2.1.0/TrueClass.html)"
+end
+
+next_step "conditionals"

sites/en/ruby/classes.step

@@ -0,0 +1,43 @@
+goals do
+  goal "Define a new object"
+  goal "Create an instance of your object"
+  goal "Call methods on your object"
+end
+
+step do
+  message 'Create a new file called circle.rb'
+  type_in_file 'circle.rb', <<-'CONTENTS'
+class Circle
+  def initialize(radius)
+    @radius = radius
+  end
+
+  def area
+    Math::PI * (@radius ** 2)
+  end
+
+  def perimeter
+    2 * Math::PI * @radius
+  end
+end
+
+print "What is the radius of your circle? > "
+radius = gets.to_i
+
+a_circle = Circle.new(radius)
+puts "Your circle has an area of #{a_circle.area}"
+puts "Your circle has a perimeter of #{a_circle.perimeter}"
+  CONTENTS
+  console 'ruby circle.rb'
+  message 'When prompted, type in a radius for your circle.'
+end
+
+explanation do
+  message "Functions by themselves aren't always enough to keep your program organized. **Object-oriented programming** was developed to keep related data (attributes) and functions that work on that data (methods) together."
+  message "In Ruby, a new object is defined with the **class** keyword, followed by the name of your object (typically CamelCased). You finish the object definition later on with an **end**."
+  message "Most objects define a special method, **initialize**, that saves the initial data your object is created with (here, a radius) and performs any other required set-up."
+  message "You create an **instance** of your object with the **new** method. Arguments passed in to **new** are sent to your **initialize** method."
+  message "Data is stored on your object using **instance variables** that start with an `@` sign. Instance variables behave like normal variables, but are only visible from inside a specific instance of your object. If you want the data to be externally accessible, you have to write more methods."
+end
+
+next_step 'summary:_organizing'

sites/en/ruby/datatypes.step

@@ -0,0 +1,98 @@
+goals do
+  goal "Know the basic data types"
+  goal "Know why it matters"
+  message "Variables are easygoing about the objects they hold. You can assign a word, then assign a number, then a list of words."
+  message "But sometimes it matters what type of data we assign a variable. The fancy word for \"type of data\" is **class**."
+  message "Ruby has several built-in classes. In a later section, we'll explore how to make your own classes."
+end
+
+step do
+  message "How can you find out what class something is?"
+  irb '"Letters and words".class'
+  result "String"
+  message "\"class\" is a **method**, a behavior you can ask an object to perform. "
+  message "To call a method on an object, type the object or variable name, then
+    a period, and finally the method name. "
+  message "Here's a preview of the datatypes we'll cover:"
+  irb <<-TRYME
+'a'.class
+5.class
+3.14.class
+true.class
+:symbol.class
+[ 1, 2, 3].class
+{name: "value"}.class
+nil.class
+Class.class
+TRYME
+end
+
+step do
+  message "Different classes come with different methods. Browse the String
+    class' methods. (Ruby will put a ':' before the method name.)"
+  irb '"five".methods'
+  message "There are a lot of them. Can you predict what some of them do?"
+  message "Numbers have different methods."
+  irb "5.methods"
+  message "Notice that number methods include arithmetic operators."
+  message "Knowing what class an object is tells us what methods we can call."
+end
+
+step do
+  message "Some datatypes are incompatible.  For example, Ruby knows how to
+    concatenate two objects of the same class."
+  irb <<-TRYME
+5 + 5
+"5" + "5"
+TRYME
+  message "Ruby can guess how to convert some classes into a similar class."
+  irb "5 + 5.0"
+  message "... but it's totally confused by different objects."
+  irb <<-TRYME
+5 + "5"
+"5" + 5
+TRYME
+end
+
+step do
+  message "When you have incompatible data types, you can use an object's
+    *conversion methods* to get a translated version of the object."
+  message "Conversion methods can be spotted by their name; they begin with
+    `to_`, e.g. `to_s` converts to a string, `to_i` to an integer, and `to_f` to
+    a float (decimal)."
+  irb <<-TRYME
+5.to_s
+5.to_s.class
+5.to_f
+5.to_f.class
+5.67.to_i
+"5".to_i
+"5".to_i.class
+TRYME
+  message "There isn't always a sensible conversion from one class to another."
+  irb <<-TRYME
+"I am not a number".to_i
+"five".to_i
+TRYME
+  message "Conversion methods are used most often in calculations and in printing."
+  irb <<-TRYME
+5 + "5".to_i
+"5 plus" + 5.to_s
+TRYME
+  message "It's common to include a `to_s` method when you make your own classes so it prints nicely."
+  message "To explore further, try converting the examples in step 1 to
+    different classes.  To more easily see what conversion methods an object has,
+    call `methods.sort` on it."
+  irb "5.methods.sort"
+end
+
+explanation do
+  message "Sometimes it's necessary to think about what type of data you're working with."
+  message "Use the `class` method to find out what class an object is."
+  message "Use the `methods` method to find out what methods an object has."
+  message "Use conversion methods to get a transformed version of an object."
+  message "A `TypeError` message is a hint to look more carefully at an object's class."
+  message "Let's look at the basic datatypes in more detail."
+end
+
+next_step "strings"

sites/en/ruby/getting_help.step

@@ -0,0 +1,20 @@
+
+goals do
+    goal "Know where to find Ruby documentation"
+    goal "Read an error message"
+    goal "Meet StackOverflow"
+end
+
+message do
+end
+
+step do
+end
+
+step do
+end
+
+step do
+end
+
+next_step "summary:_tools"