Refactor memoized helpers

lib/rspec/core/memoized_helpers.rb

@@ -190,16 +190,12 @@ module ClassMethods
         #     end
         #   end
         def let(name, &block)
-          # We have to pass the block directly to `define_method` to
-          # allow it to use method constructs like `super` and `return`.
-          raise "#let or #subject called without a block" if block.nil?
-          MemoizedHelpers.module_for(self).send(:define_method, name, &block)
-
-          # Apply the memoization. The method has been defined in an ancestor
-          # module so we can use `super` here to get the value.
-          define_method(name) do
-            __memoized.fetch(name) { |k| __memoized[k] = super(&nil) }
-          end
+          MemoizedHelpers.define_memoized_method(
+            self,
+            name,
+            MemoizedHelpers.memoized_method_name_for(name, 'let'),
+            &block
+          )
         end
 
         # Just like `let`, except the block is invoked by an implicit `before`
@@ -291,10 +287,11 @@ def let!(name, &block)
         # @see MemoizedHelpers#should
         def subject(name=nil, &block)
           if name
-            let(name, &block)
+            subject_method_name = MemoizedHelpers.memoized_method_name_for(name, "subject")
+            MemoizedHelpers.define_memoized_method(self, name, subject_method_name, &block)
             alias_method :subject, name
 
-            self::NamedSubjectPreventSuper.send(:define_method, name) do
+            self::NamedSubjectPreventSuper.__send__(:define_method, subject_method_name) do
               raise NotImplementedError, "`super` in named subjects is not supported"
             end
           else
@@ -477,6 +474,26 @@ def self.module_for(example_group)
         end
       end
 
+      # @api private
+      def self.memoized_method_name_for(name, let_or_subject)
+        "__rspec_#{let_or_subject}_definition_#{name}"
+      end
+
+      # @api private
+      def self.define_memoized_method(example_group, name, memoized_method_name, &block)
+        # We have to pass the block directly to `define_method` to
+        # allow it to use method constructs like `super` and `return`.
+        raise "#let or #subject called without a block" if block.nil?
+
+        MemoizedHelpers.module_for(example_group).__send__(:define_method, memoized_method_name, &block)
+
+        # Apply the memoization. The method has been defined in an ancestor
+        # module so we can use `super` here to get the value.
+        example_group.__send__(:define_method, name) do
+          __memoized.fetch(name) { |k| __memoized[k] = send(memoized_method_name, &nil) }
+        end
+      end
+
       if Module.method(:const_defined?).arity == 1 # for 1.8
         # @api private
         #

spec/rspec/core/memoized_helpers_spec.rb

@@ -616,6 +616,24 @@ def define_and_run_group
         })
       end
     end
+
+    context "when included modules have hooks that define memoized helpers" do
+      it "allows memoized helpers to override methods in previously included modules" do
+        group = ExampleGroup.describe do
+          include Module.new {
+            def self.included(m); m.let(:unrelated) { :unrelated }; end
+          }
+
+          include Module.new {
+            def hello_message; "Hello from module"; end
+          }
+
+          let(:hello_message) { "Hello from let" }
+        end
+
+        expect(group.new.hello_message).to eq("Hello from let")
+      end
+    end
   end
 
   describe "#let!" do