Pad Hash#inspect, Tuple#inspect before { from first element (#16245)

This ensures the output is valid Crystal code and doesn't get confused with a macro expansion.

Author: andrykonchin

spec/std/hash_spec.cr

@@ -596,7 +596,24 @@ describe "Hash" do
     it do
       h = {} of RecursiveHash => RecursiveHash
       h[h] = h
-      h.to_s.should eq("{{...} => {...}}")
+      h.to_s.should eq("{ {...} => {...} }")
+    end
+
+    context "when the first key starts with '{'" do
+      it "inserts a space after '{' and before '}' when first key is a Hash, preventing macro interpolation ({{ ... }})" do
+        hash = { {1 => 2} => 3 }
+        hash.to_s.should eq("{ {1 => 2} => 3 }")
+      end
+
+      it "inserts a space after '{' and before '}' when first key is a Tuple, preventing macro interpolation ({{ ... }})" do
+        hash = { {1, 2, 3} => 4 }
+        hash.to_s.should eq("{ {1, 2, 3} => 4 }")
+      end
+
+      it "inserts a space after '{' and before '}' when first key is a NamedTuple, preventing macro interpolation ({{ ... }})" do
+        hash = { {a: 1} => 2 }
+        hash.to_s.should eq("{ {a: 1} => 2 }")
+      end
     end
   end
 

spec/std/tuple_spec.cr

@@ -168,8 +168,27 @@ describe "Tuple" do
     [a, b, c, d, e].min.should eq(d)
   end
 
-  it "does to_s" do
-    {1, 2, 3}.to_s.should eq("{1, 2, 3}")
+  describe "#to_s" do
+    it "returns string representation" do
+      {1, 2, 3}.to_s.should eq("{1, 2, 3}")
+    end
+
+    context "when the first element starts with '{'" do
+      it "inserts a space after '{' and before '}' when the first element is a Hash, preventing macro interpolation ({{ ... }})" do
+        tuple = { {1 => 2} }
+        tuple.to_s.should eq("{ {1 => 2} }")
+      end
+
+      it "inserts a space after '{' and before '}' when the first element is a Tuple, preventing macro interpolation ({{ ... }})" do
+        tuple = { {1, 2, 3} }
+        tuple.to_s.should eq("{ {1, 2, 3} }")
+      end
+
+      it "inserts a space after '{' and before '}' when the first element is a NamedTuple, preventing macro interpolation ({{ ... }})" do
+        tuple = { {a: 1} }
+        tuple.to_s.should eq("{ {a: 1} }")
+      end
+    end
   end
 
   it "does each" do

src/hash.cr

@@ -2044,7 +2044,10 @@ class Hash(K, V)
   # ```
   def to_s(io : IO) : Nil
     executed = exec_recursive(:to_s) do
+      needs_padding = curly_like?(self.first_key?)
+
       io << '{'
+      io << ' ' if needs_padding
       found_one = false
       each do |key, value|
         io << ", " if found_one
@@ -2053,11 +2056,21 @@ class Hash(K, V)
         value.inspect(io)
         found_one = true
       end
+      io << ' ' if needs_padding
       io << '}'
     end
     io << "{...}" unless executed
   end
 
+  private def curly_like?(object)
+    case object
+    when Hash, Tuple, NamedTuple
+      true
+    else
+      false
+    end
+  end
+
   def pretty_print(pp) : Nil
     executed = exec_recursive(:pretty_print) do
       pp.list("{", self, "}") do |key, value|

src/tuple.cr

@@ -587,11 +587,26 @@ struct Tuple
   # tuple.to_s # => "{1, \"hello\"}"
   # ```
   def to_s(io : IO) : Nil
+    needs_padding = curly_like?(self.first?)
+
     io << '{'
+    io << ' ' if needs_padding
+
     join io, ", ", &.inspect(io)
+
+    io << ' ' if needs_padding
     io << '}'
   end
 
+  private def curly_like?(object)
+    case object
+    when Hash, Tuple, NamedTuple
+      true
+    else
+      false
+    end
+  end
+
   def pretty_print(pp) : Nil
     pp.list("{", self, "}")
   end