Merge pull request #8 from daigaku-ruby/add-chapter-strings

Add chapter strings

Author: paulgoetze

3_Strings/1_Interpolation/solution.rb

@@ -0,0 +1,4 @@
+# e.g.
+firstname = 'Peter'
+lastname = 'Pan'
+fullname = "#{lastname}, #{firstname}"

3_Strings/1_Interpolation/solution_spec.rb

@@ -0,0 +1,71 @@
+require 'rspec'
+require 'rspec/expectations'
+require 'code_breaker'
+
+RSpec::Matchers.define :run_string_interpolation do |expected|
+  match do |actual|
+    interpolation = interpolation_part_of(actual)
+    return false if interpolation.nil?
+    interpolation[:lvasgn][1][:dstr] == expected
+  end
+
+  failure_message do |actual|
+    actual_line = actual.split("\n").select do |line|
+      line =~ /fullname\s?=.+/
+    end
+
+    parsed_line = CodeBreaker.parse(actual_line.join)
+    interpolation = parsed_line[:lvasgn].last
+
+    unless interpolation.is_a?(Hash) && interpolation[:dstr]
+      return "You didn't do any string interpolation."
+    end
+
+    [['solution::code']]
+
+    %Q{Your interpolated fullname shoud be "#{lastname}, #{firstname}"
+    ------- but is "#{fullname}".}
+  end
+
+  def interpolation_part_of(actual)
+    parsed = CodeBreaker.parse(actual)
+
+    interpolation = parsed.select do |part|
+      next unless part.is_a?(Hash)
+      next unless part.has_key?(:lvasgn)
+      next unless part[:lvasgn][0] == :fullname
+      next unless part[:lvasgn][1].is_a?(Hash)
+
+      part[:lvasgn][1].has_key?(:dstr)
+    end
+
+    interpolation.first
+  end
+end
+
+describe "Your code" do
+  [['solution::code']]
+
+  VARIABLES = [:firstname, :lastname, :fullname].freeze
+
+  VARIABLES.each do |name|
+    it "defines a variable with name \"#{name}\"" do
+      expect(local_variables.include?(name)).to be true
+    end
+
+    if name != :fullname && local_variables.include?(name)
+      it "assigns a String to the variable \"#{name}\"" do
+        expect(eval(name.to_s)).to be_a String
+      end
+    end
+  end
+
+  if (local_variables & VARIABLES).sort == VARIABLES.sort
+    it "creates an interpolated String" do
+      statement = [[{ lvar: :lastname }], String, [{ lvar: :firstname }]]
+      code_lines = %q{ [['solution::code']] }
+
+      expect(code_lines).to run_string_interpolation(statement)
+    end
+  end
+end

3_Strings/1_Interpolation/task.md

@@ -0,0 +1,41 @@
+# Interpolation
+
+---
+
+*You will learn:*
+- how to create interpolated Strings
+
+---
+
+You already learned that you can define a String with either single quotes or
+double quotes. The resulting String is the same, but if you use the double quotes
+for creating a String you can interpolate variables within this string.
+
+The interpolated statement has to be wrapped in *#{}* – a hash followed by curly brackets.
+Let's look at an example:
+
+`  amount = 5`
+`  message = "I learned` *#{amount}* `units today."`
+
+The variable `message` now has the value *"I learned 5 units today."*.
+If you would use single quotes then the String would not evaluate the *#{}* part:
+
+`  message = 'I learned #{amount} units today.'`
+
+The variable `message` has the value *"I learned #{amount} values today."* –
+the value of `amount` will not be interpolated into the String.
+
+A common pattern is:
+
+\* You should use single quotes `''` for Strings that are not interpolated
+\* You should only use double quotes `""` for Strings that should be interpolated
+
+---
+
+Define a variable `firstname` and `lastname` with your firstname and lastname as values.
+Then create a variable `fullname` and assign an interpolated String by using
+the `lastname` and `firstname` variables.
+
+The resulting String should look like *"YourLastname, YourFirstname"*.
+
+ ---

3_Strings/2_Concatenating_Strings/solution.rb

@@ -0,0 +1,5 @@
+# e.g.
+('Ruby' << 32) + 'r' + 'o' * 5 + 'cks' << 33
+
+# or
+'Ruby'.concat(32) + 'r' + 'o' * 5 + 'cks'.concat(33)

3_Strings/2_Concatenating_Strings/solution_spec.rb

@@ -0,0 +1,51 @@
+require 'rspec'
+require 'rspec/expectations'
+
+RSpec::Matchers.define :use_multiplication_of_strings do
+  match { |actual| actual =~ /['"]o['"]\s?\*\s?\d+/ }
+
+  failure_message do |actual|
+    %Q{Your code doesn't use the * method to add the "o"s}
+  end
+end
+
+RSpec::Matchers.define :concat_the_ordinal_number do |expected|
+  match { |actual| actual =~ /(<<[\(\s]?#{expected}\)?|\.concat[\(\s]#{expected}\(?)/ }
+
+  failure_message do |actual|
+    %Q{Your code doesn't add "#{expected.chr}" by using the ordinal number}
+  end
+end
+
+def code_line
+  %q{[['solution::code']]}
+end
+
+def code
+  @code ||= eval(code_line)
+end
+
+describe 'Your code' do
+  it 'creates a String' do
+    expect(code).to be_a String
+  end
+
+  it 'adds whitespace by using the ordinal number' do
+    expect(code_line).to concat_the_ordinal_number 32
+  end
+
+  it 'uses the * method to create the "ooooo"' do
+    expect(code_line).to use_multiplication_of_strings
+  end
+
+  it 'adds an exclamation mark by using the ordinal number' do
+    expect(code_line).to concat_the_ordinal_number 33
+  end
+
+
+  if code.is_a?(String)
+    it 'forms the String "Ruby rooooocks!"' do
+      expect(code.strip).to eq 'Ruby rooooocks!'
+    end
+  end
+end

3_Strings/2_Concatenating_Strings/task.md

@@ -0,0 +1,97 @@
+# Concatenating Strings
+
+---
+
+*You will learn:*
+- how to concatenate Strings
+- how to append a String to another String
+- about the ordinal number representation of Strings
+
+---
+
+If you look into Ruby's documentation for the the *String* class you will find several
+methods to concatenate Strings: *(ruby-doc core: String)*.
+
+Adding a String to another String is an often used operation when working with Strings.
+In Ruby there are two possibilities to combine Strings:
+
+`1) You can connect two Strings and create a third String out of them`
+`2) You can directly modify an existing String`
+
+Let's have a closer look into both the options:
+
+## Combining Strings into a new String
+
+A String comes with 2 methods to do this, namely `+` and `\*`.
+You might think "Wait, these are Number operations!". Right, but the *String* class
+does also define them.
+
+The `+` method just adds a second String to the end of the first one:
+
+`  'white' + 'space'` *# => "whitespace"*
+
+If you want to have whitespace between these words you have explicitly add it to
+the end of the first or the beginning of the second String.
+
+The `\*` method takes an Integer *n* and runs the `+`-concatenation *n* times:
+
+`  'la' \* 3`         *# => "lalala"* (here n = 3)
+
+If your first String was stored in a variable, then a concatenation with the `+` and `\*`
+methods doesn't change the value of this variable:
+
+`  name = 'Ada'`
+`  fullname = name + ' Lovelace'` *# => "Ada Lovelace"
+`  puts fullname`                 *# => "Ada Lovelace"
+`  puts name`                     *# => "Ada"
+
+The variable `name` still has the value *"Ada"*, `fullname` holds the concatenated String.
+
+## Directly modifying a String
+
+There are two methods for directly adding a String to another String: `<<` and `concat`.
+
+The `<<` method works like `+` with the difference however that it adds the second String
+to the first one. Let's take the example from above again:
+
+`  name = 'Ada'`
+`  name << ' Lovelace'`  *# => "Ada Lovelace"
+`  puts name`            *# => "Ada Lovelace"
+
+The value of *name* is now the concatenation.
+
+The method `concat` works the same but just has a more recognizable name:
+
+`  name = 'William'`
+`  name.concat(' King')` *# => "William King"
+`  puts name`            *# => "William King"
+
+Both `<<` and `concat` also take an integer number as parameter.
+Hm, how can we add an Integer value to a String? The answer is that each one-character
+String has an Integer representation (ordinal number). You can check which ordinal number
+a character has by using the `ord` method:
+
+`  'A'.ord`              *# => 65*
+`  '?'.ord`              *# => 63*
+
+This means if you write
+
+`  'Pardon'.concat(63)`  *# => "Pardon?"*
+
+then the *63* is first converted to its String representation and then added to the first String.
+
+If you want to add a number – as it is – to a String, you have to convert it to a String before.
+You can use the `to_s` method to achive this:
+
+`  'User' << 1.to_s`     *# => "User1"*
+
+Now that we learned about all these methods, let's concatenate some Strings!
+
+---
+
+Create the String *"Ruby rooooocks!"* by using the methods `+`, `\*` and `<<` or `concat`!
+
+Create the whitespace and the exclamation mark by concatenating ordinal numbers to the String.
+Use the `\*` method to add the multiple *ooooo*s to the String.
+
+---