Change default legacy_mode state to off

Swaps the default to be off, so that individual cases can be
toggled on in when the json gem is upgraded.

lib/gitlab/json.rb

@@ -9,13 +9,18 @@ module Gitlab
         legacy_mode = legacy_mode_enabled?(named_args.delete(:legacy_mode))
         data = adapter.parse(string, *args, **named_args)
 
-        raise parser_error if legacy_mode && INVALID_LEGACY_TYPES.any? { |type| data.is_a?(type) }
+        handle_legacy_mode!(data) if legacy_mode
 
         data
       end
 
-      def parse!(*args)
-        adapter.parse!(*args)
+      def parse!(string, *args, **named_args)
+        legacy_mode = legacy_mode_enabled?(named_args.delete(:legacy_mode))
+        data = adapter.parse!(string, *args, **named_args)
+
+        handle_legacy_mode!(data) if legacy_mode
+
+        data
       end
 
       def dump(*args)
@@ -41,11 +46,13 @@ module Gitlab
       end
 
       def legacy_mode_enabled?(arg_value)
-        if ::JSON::VERSION_MAJOR >= 2
-          arg_value.nil? ? true : arg_value
-        else
-          true
-        end
+        arg_value.nil? ? false : arg_value
+      end
+
+      def handle_legacy_mode!(data)
+        return data unless Feature.enabled?(:json_wrapper_legacy_mode, default_enabled: true)
+
+        raise parser_error if INVALID_LEGACY_TYPES.any? { |type| data.is_a?(type) }
       end
     end
   end

spec/lib/gitlab/json_spec.rb

@@ -3,8 +3,12 @@
 require "spec_helper"
 
 RSpec.describe Gitlab::Json do
+  before do
+    stub_feature_flags(json_wrapper_legacy_mode: true)
+  end
+
   describe ".parse" do
-    context "legacy_mode is on by default" do
+    context "legacy_mode is disabled by default" do
       it "parses an object" do
         expect(subject.parse('{ "foo": "bar" }')).to eq({ "foo" => "bar" })
       end
@@ -13,6 +17,8 @@ RSpec.describe Gitlab::Json do
         expect(subject.parse('[{ "foo": "bar" }]')).to eq([{ "foo" => "bar" }])
       end
 
+      # These tests will change expectations when the gem is upgraded
+
       it "raises an error on a string" do
         expect { subject.parse('"foo"') }.to raise_error(JSON::ParserError)
       end
@@ -26,52 +32,74 @@ RSpec.describe Gitlab::Json do
       end
     end
 
-    context "legacy_mode is disabled" do
+    context "legacy_mode is enabled" do
       it "parses an object" do
-        expect(subject.parse('{ "foo": "bar" }', legacy_mode: false)).to eq({ "foo" => "bar" })
+        expect(subject.parse('{ "foo": "bar" }', legacy_mode: true)).to eq({ "foo" => "bar" })
       end
 
       it "parses an array" do
-        expect(subject.parse('[{ "foo": "bar" }]', legacy_mode: false)).to eq([{ "foo" => "bar" }])
+        expect(subject.parse('[{ "foo": "bar" }]', legacy_mode: true)).to eq([{ "foo" => "bar" }])
       end
 
-      # These are expected errors now until we upgrade the `json` gem,
-      # and then it will be expected to not raise errors and these tests
-      # will be updated accordingly.
-
       it "raises an error on a string" do
-        expect { subject.parse('"foo"', legacy_mode: false) }.to raise_error(JSON::ParserError)
+        expect { subject.parse('"foo"', legacy_mode: true) }.to raise_error(JSON::ParserError)
       end
 
       it "raises an error on a true bool" do
-        expect { subject.parse("true", legacy_mode: false) }.to raise_error(JSON::ParserError)
+        expect { subject.parse("true", legacy_mode: true) }.to raise_error(JSON::ParserError)
       end
 
       it "raises an error on a false bool" do
-        expect { subject.parse("false", legacy_mode: false) }.to raise_error(JSON::ParserError)
+        expect { subject.parse("false", legacy_mode: true) }.to raise_error(JSON::ParserError)
       end
     end
   end
 
   describe ".parse!" do
-    it "parses an object" do
-      expect(subject.parse!('{ "foo": "bar" }')).to eq({ "foo" => "bar" })
-    end
+    context "legacy_mode is disabled by default" do
+      it "parses an object" do
+        expect(subject.parse!('{ "foo": "bar" }')).to eq({ "foo" => "bar" })
+      end
 
-    it "parses an array" do
-      expect(subject.parse!('[{ "foo": "bar" }]')).to eq([{ "foo" => "bar" }])
-    end
+      it "parses an array" do
+        expect(subject.parse!('[{ "foo": "bar" }]')).to eq([{ "foo" => "bar" }])
+      end
 
-    it "raises an error on a string" do
-      expect { subject.parse!('"foo"') }.to raise_error(JSON::ParserError)
-    end
+      # These tests will change expectations when the gem is upgraded
+
+      it "raises an error on a string" do
+        expect { subject.parse!('"foo"') }.to raise_error(JSON::ParserError)
+      end
+
+      it "raises an error on a true bool" do
+        expect { subject.parse!("true") }.to raise_error(JSON::ParserError)
+      end
 
-    it "raises an error on a true bool" do
-      expect { subject.parse!("true") }.to raise_error(JSON::ParserError)
+      it "raises an error on a false bool" do
+        expect { subject.parse!("false") }.to raise_error(JSON::ParserError)
+      end
     end
 
-    it "raises an error on a false bool" do
-      expect { subject.parse!("false") }.to raise_error(JSON::ParserError)
+    context "legacy_mode is enabled" do
+      it "parses an object" do
+        expect(subject.parse!('{ "foo": "bar" }', legacy_mode: true)).to eq({ "foo" => "bar" })
+      end
+
+      it "parses an array" do
+        expect(subject.parse!('[{ "foo": "bar" }]', legacy_mode: true)).to eq([{ "foo" => "bar" }])
+      end
+
+      it "raises an error on a string" do
+        expect { subject.parse!('"foo"', legacy_mode: true) }.to raise_error(JSON::ParserError)
+      end
+
+      it "raises an error on a true bool" do
+        expect { subject.parse!("true", legacy_mode: true) }.to raise_error(JSON::ParserError)
+      end
+
+      it "raises an error on a false bool" do
+        expect { subject.parse!("false", legacy_mode: true) }.to raise_error(JSON::ParserError)
+      end
     end
   end