Fix another bug in metadata backwards compatibility.

In RSpec 2.x, an example's `metadata[:example_group]`
did not returned it's example group's `metadata`,
but rather it's example group's `metadata[:example_group]`,
which is where all the computed values for the example
group went.

In RSpec 3, we've simplified this nesting structure
(it's silly to put an example group's computed
properties on a nested subhash keyed by `:example_group`),
but our backwards compatibility didn't work properly with this.

The problem was that `example.metadata[:example_group][:example_group]`
returned the `LegacyExampleGroupHash` available off of
`example.example_group.metadata[:example_group]`, which contains
the computed properties of the example group, but on 2.99 this
returned the computed properties of the parent group of the example's
group.

Unfortunately, I had to make one spec pending as I can't find
a way to keep it passing with the difference in how the
metadata is exposed from an example vs a group, but it really
only matters when people mutate the metadata hash and that's
not a normal, supported use case.  I think the backwards compatibility
is more important right now.  We may revert this at some point
after 3.0's been out for awhile and people have had time to
adjust to the deprecation warnings issued for the metadata changes.

Author: myronmarston

lib/rspec/core/metadata.rb

@@ -149,6 +149,11 @@ def ensure_valid_user_keys
       class ExampleHash < HashPopulator
         def self.create(group_metadata, user_metadata, description, block)
           example_metadata = group_metadata.dup
+          group_metadata = Hash.new(&ExampleGroupHash.backwards_compatibility_default_proc do |hash|
+            hash[:parent_example_group]
+          end)
+          group_metadata.update(example_metadata)
+
           example_metadata[:example_group] = group_metadata
           example_metadata.delete(:parent_example_group)
 
@@ -184,14 +189,18 @@ def self.create(parent_group_metadata, user_metadata, *args, &block)
         end
 
         def self.hash_with_backwards_compatibility_default_proc
-          Hash.new do |hash, key|
+          Hash.new(&backwards_compatibility_default_proc { |hash| hash })
+        end
+
+        def self.backwards_compatibility_default_proc(&example_group_selector)
+          Proc.new do |hash, key|
             case key
             when :example_group
               RSpec.deprecate("The `:example_group` key in an example group's metadata hash",
                               :replacement => "the example group's hash directly for the " +
                               "computed keys and `:parent_example_group` to access the parent " +
                               "example group metadata")
-              LegacyExampleGroupHash.new(hash)
+              LegacyExampleGroupHash.new(example_group_selector.call(hash))
             when :example_group_block
               RSpec.deprecate("`metadata[:example_group_block]`",
                               :replacement => "`metadata[:block]`")

spec/rspec/core/metadata_spec.rb

@@ -117,6 +117,8 @@ def metadata_for(*args)
           end
 
           a[:description] = "new description"
+
+          pending "Cannot maintain this and provide full `:example_group` backwards compatibility (see GH #1490):("
           expect(b[:description]).to eq("new description")
         end
 
@@ -473,11 +475,12 @@ def value_for(*args)
             RSpec.describe "Level 1" do
               describe "Level 2" do
                 describe "Level 3" do
-                  inner_metadata = metadata
+                  inner_metadata = example("Level 4").metadata
                 end
               end
             end
 
+            expect(inner_metadata[:description]).to eq("Level 4")
             expect(inner_metadata[:example_group][:description]).to eq("Level 3")
             expect(inner_metadata[:example_group][:example_group][:description]).to eq("Level 2")
             expect(inner_metadata[:example_group][:example_group][:example_group][:description]).to eq("Level 1")