Finish up numbers - basic operators task

Author: paulgoetze

2_Numbers/2_Basic_operators/solution.rb

@@ -0,0 +1,6 @@
+# e.g.
+sum = Rational(1, 3) + Rational(2)
+difference = 1_000_000_000_000_000_000_000_000 - 1.9
+product = 2.4 * 5.6 * 2.3
+quotient = Complex(1) / 3.4
+power = Rational(2, 3) ** 3.5

2_Numbers/2_Basic_operators/solution_spec.rb

@@ -1,40 +1,56 @@
 require 'rspec'
+require 'rspec/expectations'
 
-describe "Your code" do
-  [['solution::code']]
+# requires code_breaker gem to be installed
+# (https://github.com/daigaku-ruby/code_breaker)
+require 'code_breaker'
 
-  sum = Rational(1, 2) + Rational(2, 4)
-  difference = 100_000_000_000_000 - 2500.25
-  product = 1.578 + 2.7 + 0.42
-  quotient = Complex(3.5, 5.25) / 8.75
-  power = Rational(11/13) ** 11.13
+RSpec::Matchers.define :run_number_operations do |expected|
+  match do |actual|
+    lines = actual.split("\n").compact.map(&:strip).reject(&:empty?)
+    called_operations(lines).include?(expected)
+  end
 
+  def called_operations(lines)
+    lines.map do |line|
+      CodeBreaker.parse(line)
+    end
+  end
 
-  {
-    sum: [Rational, Rational, :+],
-    difference: [Bignum, Float, :-],
-    product: [Float, Float, Float, :*],
-    quotient: [Complex, Float, :/],
-    power: [Rational, Float, :**]
-  }.each do |operation, values|
+  failure_message do |actual|
+    %Q{Your code doesn't run the number operation "#{expected.join(' ')}".}
+  end
+end
+
+OPERATIONS = {
+  sum:        [Rational, :+, Rational],
+  difference: [Bignum, :-, Float],
+  product:    [Float, :*, Float, :*, Float],
+  quotient:   [Complex, :/, Float],
+  power:      [Rational, :**, Float]
+}.freeze
+
+describe "Your code" do
+  [['solution::code']]
+
+  OPERATIONS.each do |operation, values|
     it "defines a variable with name \"#{operation}\"" do
       expect(local_variables.include?(operation)).to be true
     end
 
     if local_variables.include?(operation)
-      same_operants = (values[0..-2].uniq.count == 1)
+      operants  = values.select.each_with_index { |_, i| i.even? }
+      same_operants = (operants.uniq.count == 1)
 
-      class_list = if same_operants
-        "#{values[0..-2].count} #{values.first} numbers"
+      numbers = if same_operants
+        "#{operants.count} #{values.first} numbers"
       else
-        values[0..-2].join(' and a ')
+        operants.join(' and a ')
       end
 
-      it "calculates the #{operation} of #{class_list}" do
-        expect_any_instance_of(values.first)
-          .to receive(values.last).exactly(values.count - 2).times
-
-        [['solution::code']]
+      it "calculates the #{operation} of #{numbers}" do
+        code_lines = %Q{ [['solution::code']] }
+        expect(code_lines).to run_number_operations(values)
       end
     end
   end

2_Numbers/2_Basic_operators/task.md

@@ -21,7 +21,7 @@ You can apply these arithmetic operators by writing one of them between two
 numbers, e.g.:
 
 `  3.2 + 7`                              # => 10.2
-`  Rational(2, 3) - Rational(1, 2)`      # =>  (1/6)
+`  Rational(2, 3) - Rational(1, 2)`      # => (1/6)
 `  3 \* 5`                                # => 15
 `  Complex(2.0, 4) / Complex(4.0, 2.0)`  # => (0.8+0.6000000000000001i)
 `  2 \*\* 3`                               # => 8
@@ -53,14 +53,14 @@ http://docs.sun.com/source/806-3568/ncg_goldberg.html!)
 
 This binary representation of *Floats* is also the explanation for the inaccuracy
 when calculating the division of two *Complex* numbers (as in the example above,
-where the maginary part is *0.6000000000000001* instead of *0.6*).
+where the imaginary part is *0.6000000000000001* instead of *0.6*).
 
 ---
 
 Connect numbers by each of the learned operators:
 
 1. Sum up two *Rational* numbers
-2. Subtract a *Float* from an *Bignum*
+2. Subtract a *Float* from a *Bignum*
 3. Build the product of three *Float* numbers
 4. Divide a *Complex* number by a *Fixnum*
 5. Calculate a *Rational* to the power of a *Float*