1 files changed, 116 insertions, 70 deletions
diff --git a/spec/ruby/language/safe_navigator_spec.rb b/spec/ruby/language/safe_navigator_spec.rb
index a8b29dc5a3..e8b429631d 100644
--- a/spec/ruby/language/safe_navigator_spec.rb
+++ b/spec/ruby/language/safe_navigator_spec.rb
@@ -1,101 +1,147 @@
-require File.expand_path("../../spec_helper", __FILE__)
+require_relative '../spec_helper'
 
-ruby_version_is "2.3" do
-  describe "Safe navigator" do
-    it "requires a method name to be provided" do
-      lambda { eval("obj&. {}") }.should raise_error(SyntaxError)
+describe "Safe navigator" do
+  it "requires a method name to be provided" do
+    -> { eval("obj&. {}") }.should.raise(SyntaxError)
+  end
+
+  context "when context is nil" do
+    it "always returns nil" do
+      nil&.unknown.should == nil
+      [][10]&.unknown.should == nil
     end
 
-    context "when context is nil" do
-      it "always returns nil" do
-        eval("nil&.unknown").should == nil
-        eval("[][10]&.unknown").should == nil
-      end
+    it "can be chained" do
+      nil&.one&.two&.three.should == nil
+    end
 
-      it "can be chained" do
-        eval("nil&.one&.two&.three").should == nil
-      end
+    it "doesn't evaluate arguments" do
+      obj = Object.new
+      obj.should_not_receive(:m)
+      nil&.unknown(obj.m) { obj.m }
+    end
+  end
 
-      it "doesn't evaluate arguments" do
-        obj = Object.new
-        obj.should_not_receive(:m)
-        eval("nil&.unknown(obj.m) { obj.m }")
-      end
+  context "when context is false" do
+    it "calls the method" do
+      false&.to_s.should == "false"
+
+      -> { false&.unknown }.should.raise(NoMethodError)
     end
+  end
 
-    context "when context is false" do
-      it "calls the method" do
-        eval("false&.to_s").should == "false"
+  context "when context is truthy" do
+    it "calls the method" do
+      1&.to_s.should == "1"
 
-        lambda { eval("false&.unknown") }.should raise_error(NoMethodError)
-      end
+      -> { 1&.unknown }.should.raise(NoMethodError)
     end
+  end
 
-    context "when context is truthy" do
-      it "calls the method" do
-        eval("1&.to_s").should == "1"
+  it "takes a list of arguments" do
+    [1,2,3]&.first(2).should == [1,2]
+  end
+
+  it "takes a block" do
+    [1,2]&.map { |i| i * 2 }.should == [2, 4]
+  end
 
-        lambda { eval("1&.unknown") }.should raise_error(NoMethodError)
+  it "allows assignment methods" do
+    klass = Class.new do
+      attr_reader :foo
+      def foo=(val)
+        @foo = val
+        42
       end
     end
+    obj = klass.new
 
-    it "takes a list of arguments" do
-      eval("[1,2,3]&.first(2)").should == [1,2]
-    end
+    (obj&.foo = 3).should == 3
+    obj.foo.should == 3
 
-    it "takes a block" do
-      eval("[1,2]&.map { |i| i * 2 }").should == [2, 4]
-    end
+    obj = nil
+    (obj&.foo = 3).should == nil
+  end
 
-    it "allows assignment methods" do
-      klass = Class.new do
-        attr_reader :foo
-        def foo=(val)
-          @foo = val
-          42
-        end
-      end
-      obj = klass.new
+  it "allows assignment operators" do
+    klass = Class.new do
+      attr_reader :m
 
-      eval("obj&.foo = 3").should == 3
-      obj.foo.should == 3
+      def initialize
+        @m = 0
+      end
 
-      obj = nil
-      eval("obj&.foo = 3").should == nil
+      def m=(v)
+        @m = v
+        42
+      end
     end
 
-    it "allows assignment operators" do
-      klass = Class.new do
-        attr_accessor :m
+    obj = klass.new
 
-        def initialize
-          @m = 0
-        end
-      end
+    obj&.m += 3
+    obj.m.should == 3
+
+    obj = nil
+    (obj&.m += 3).should == nil
+  end
 
-      obj = klass.new
+  it "allows ||= operator" do
+    klass = Class.new do
+      attr_reader :m
 
-      eval("obj&.m += 3")
-      obj.m.should == 3
+      def initialize
+        @m = false
+      end
 
-      obj = nil
-      eval("obj&.m += 3").should == nil
+      def m=(v)
+        @m = v
+        42
+      end
     end
 
-    it "does not call the operator method lazily with an assignment operator" do
-      klass = Class.new do
-        attr_writer :foo
-        def foo
-          nil
-        end
+    obj = klass.new
+
+    (obj&.m ||= true).should == true
+    obj.m.should == true
+
+    obj = nil
+    (obj&.m ||= true).should == nil
+    obj.should == nil
+  end
+
+  it "allows &&= operator" do
+    klass = Class.new do
+      attr_accessor :m
+
+      def initialize
+        @m = true
       end
-      obj = klass.new
+    end
+
+    obj = klass.new
+
+    (obj&.m &&= false).should == false
+    obj.m.should == false
 
-      lambda {
-        eval("obj&.foo += 3")
-      }.should raise_error(NoMethodError) { |e|
-        e.name.should == :+
-      }
+    obj = nil
+    (obj&.m &&= false).should == nil
+    obj.should == nil
+  end
+
+  it "does not call the operator method lazily with an assignment operator" do
+    klass = Class.new do
+      attr_writer :foo
+      def foo
+        nil
+      end
     end
+    obj = klass.new
+
+    -> {
+      obj&.foo += 3
+    }.should.raise(NoMethodError) { |e|
+      e.name.should == :+
+    }
   end
 end