method_log 0.0.5 → 0.0.6

data/spec/commit_spec.rb

@@ -1,99 +1,97 @@
+require 'spec_helper'
+
 require 'method_log/repository'
 require 'method_log/commit'
 require 'method_log/source_file'
 
-describe MethodLog::Commit do
-  let(:sha) { 'b54d38bbd989f4b54c38fd77767d89d1' }
-  let(:commit) { MethodLog::Commit.new(sha: sha) }
-  let(:commit_with_same_sha) { MethodLog::Commit.new(sha: sha) }
+module MethodLog
+  describe Commit do
+    let(:sha) { 'b54d38bbd989f4b54c38fd77767d89d1' }
+    let(:commit) { Commit.new(sha) }
+    let(:commit_with_same_sha) { Commit.new(sha) }
 
-  it 'is equal to another commit with same SHA' do
-    expect(commit).to eq(commit_with_same_sha)
-  end
+    it 'is equal to another commit with same SHA' do
+      expect(commit).to eq(commit_with_same_sha)
+    end
 
-  it 'has same hash as another commit with same SHA' do
-    expect(commit.hash).to eq(commit_with_same_sha.hash)
-  end
+    it 'has same hash as another commit with same SHA' do
+      expect(commit.hash).to eq(commit_with_same_sha.hash)
+    end
 
-  context 'using a real git repository' do
-    let(:repository_path) { File.expand_path('../repository.git', __FILE__) }
+    context 'using a real git repository' do
+      let(:repository_path) { File.expand_path('../repository.git', __FILE__) }
 
-    before do
-      FileUtils.mkdir_p(repository_path)
-      Rugged::Repository.init_at(repository_path, :bare)
-    end
+      before do
+        FileUtils.mkdir_p(repository_path)
+        Rugged::Repository.init_at(repository_path, :bare)
+      end
 
-    after do
-      FileUtils.rm_rf(repository_path)
-    end
+      after do
+        FileUtils.rm_rf(repository_path)
+      end
 
-    it 'stores source files added to a commit in the repository against a real commit' do
-      source_one = MethodLog::SourceFile.new(path: 'path/to/source_one.rb', source: 'source-one')
-      source_two = MethodLog::SourceFile.new(path: 'path/to/source_two.rb', source: 'source-two')
+      it 'stores source files added to a commit in the repository against a real commit' do
+        source_one = source(path: 'path/to/source_one.rb', source: 'source-one')
+        source_two = source(path: 'path/to/source_two.rb', source: 'source-two')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.build_commit
-      commit.add(source_one)
-      commit.add(source_two)
-      commit.apply
+        repository = Repository.new(repository_path)
+        commit = repository.commit(source_one, source_two)
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.commits.first
-      expect(commit.source_files.to_a).to eq([source_one, source_two])
-    end
+        repository = Repository.new(repository_path)
+        commit = repository.commits.first
+        expect(commit.source_files.to_a).to eq([source_one, source_two])
+      end
 
-    it 'only includes source files with ruby file extension' do
-      source_file = MethodLog::SourceFile.new(path: 'path/to/source_one.py', source: 'source-file')
+      it 'only includes source files with ruby file extension' do
+        source_file = source(path: 'path/to/source_one.py', source: 'source-file')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.build_commit
-      commit.add(source_file)
-      commit.apply
+        repository = Repository.new(repository_path)
+        commit = repository.commit(source_file)
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.commits.first
-      expect(commit.source_files.to_a).to be_empty
-    end
+        repository = Repository.new(repository_path)
+        commit = repository.commits.first
+        expect(commit.source_files.to_a).to be_empty
+      end
 
-    it 'indicates whether it contains a given source file' do
-      source_file = MethodLog::SourceFile.new(path: 'path/to/source.rb', source: 'source-file')
+      it 'indicates whether it contains a given source file' do
+        source_file = source(path: 'path/to/source.rb', source: 'source-file')
+        another_source_file = source(path: 'path/to/another_source.rb', source: 'another-source-file')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.build_commit
-      commit.add(source_file)
-      commit.apply
-      source_file = commit.source_files.first
+        repository = Repository.new(repository_path)
+        commit = repository.commit(source_file)
+        source_file = commit.source_files.first
+        another_commit = repository.commit(another_source_file)
+        another_source_file = another_commit.source_files.first
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.commits.first
-      expect(commit.contains?(source_file)).to be_true
-    end
+        repository = Repository.new(repository_path)
+        commit = repository.commits.to_a.last
 
-    it 'makes author available' do
-      user = { email: 'test@example.com', name: 'test', time: Time.now.round }
-      source_file = MethodLog::SourceFile.new(path: 'path/to/source.rb', source: 'source')
+        expect(commit.contains?(source_file)).to be_true
+        expect(commit.contains?(another_source_file)).to be_false
+      end
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.build_commit
-      commit.add(source_file)
-      commit.apply(user: user)
+      it 'makes author available' do
+        user = { email: 'test@example.com', name: 'test', time: Time.now.round }
+        source_file = source(path: 'path/to/source.rb', source: 'source')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.commits.first
-      expect(commit.author).to eq(user)
-    end
+        repository = Repository.new(repository_path)
+        commit = repository.commit(source_file, user: user)
+
+        repository = Repository.new(repository_path)
+        commit = repository.commits.first
+        expect(commit.author).to eq(user)
+      end
 
-    it 'makes message available' do
-      source_file = MethodLog::SourceFile.new(path: 'path/to/source.rb', source: 'source')
+      it 'makes message available' do
+        source_file = source(path: 'path/to/source.rb', source: 'source')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.build_commit
-      commit.add(source_file)
-      commit.apply(message: 'commit-message')
+        repository = Repository.new(repository_path)
+        commit = repository.commit(source_file, message: 'commit-message')
 
-      repository = MethodLog::Repository.new(path: repository_path)
-      commit = repository.commits.first
-      expect(commit.message).to eq('commit-message')
+        repository = Repository.new(repository_path)
+        commit = repository.commits.first
+        expect(commit.message).to eq('commit-message')
+      end
     end
   end
-end
+end

data/spec/method_commit_spec.rb

@@ -1,33 +1,37 @@
+require 'spec_helper'
+
 require 'method_log/method_commit'
 require 'method_log/commit'
 require 'method_log/source_file'
 require 'method_log/method_definition'
 
-describe MethodLog::MethodCommit do
-  let(:commit) { MethodLog::Commit.new(sha: nil) }
-  let(:source_file) { MethodLog::SourceFile.new(path: '/path/to/source.rb', source: "line 0\nline 1\nline 2\n") }
-  let(:method_definition) { MethodLog::MethodDefinition.new(source_file: source_file, lines: 0..1) }
-  let(:method_commit) {
-    MethodLog::MethodCommit.new(commit: commit, method_definition: method_definition)
-  }
-  let(:method_commit_with_same_commit_and_method_definition) {
-    MethodLog::MethodCommit.new(commit: commit, method_definition: method_definition)
-  }
+module MethodLog
+  describe MethodCommit do
+    let(:commit) { Commit.new(nil) }
+    let(:source_file) { source(path: '/path/to/source.rb', source: "line 0\nline 1\nline 2\n") }
+    let(:method_definition) { MethodDefinition.new(source_file, 0..1) }
+    let(:method_commit) {
+      MethodCommit.new(commit, method_definition)
+    }
+    let(:method_commit_with_same_commit_and_method_definition) {
+      MethodCommit.new(commit, method_definition)
+    }
 
-  it 'is equal to another method commit with same commit and method definition' do
-    expect(method_commit).to eq(method_commit_with_same_commit_and_method_definition)
-  end
+    it 'is equal to another method commit with same commit and method definition' do
+      expect(method_commit).to eq(method_commit_with_same_commit_and_method_definition)
+    end
 
-  it 'has same hash as another method commit with same commit and method definition' do
-    expect(method_commit.hash).to eq(method_commit_with_same_commit_and_method_definition.hash)
-  end
+    it 'has same hash as another method commit with same commit and method definition' do
+      expect(method_commit.hash).to eq(method_commit_with_same_commit_and_method_definition.hash)
+    end
 
-  it 'returns method source with trailing newline' do
-    expect(method_commit.method_source).to eq("line 0\nline 1\n")
-  end
+    it 'returns method source with trailing newline' do
+      expect(method_commit.method_source).to eq("line 0\nline 1\n")
+    end
 
-  it 'returns nil if no method definition' do
-    method_commit = MethodLog::MethodCommit.new(commit: commit, method_definition: nil)
-    expect(method_commit.method_source).to be_nil
+    it 'returns nil if no method definition' do
+      method_commit = MethodCommit.new(commit, method_definition = nil)
+      expect(method_commit.method_source).to be_nil
+    end
   end
-end
+end

data/spec/method_definition_spec.rb

@@ -1,34 +1,38 @@
+require 'spec_helper'
+
 require 'method_log/method_definition'
 require 'method_log/source_file'
 
-describe MethodLog::MethodDefinition do
-  let(:source_file) do
-    MethodLog::SourceFile.new(path: 'path/to/source.rb', source: %{
-class Foo
-  def bar
-    # implementation
-  end
-end
-    }.strip)
-  end
+module MethodLog
+  describe MethodDefinition do
+    let(:source_file) do
+      source(path: 'path/to/source.rb', source: %{
+        class Foo
+          def bar
+            # implementation
+          end
+        end
+      })
+    end
 
-  it 'is equal to another method definition with same source file and line numbers' do
-    definition_one = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
-    definition_two = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
+    it 'is equal to another method definition with same source file and line numbers' do
+      definition_one = MethodDefinition.new(source_file, 1..3)
+      definition_two = MethodDefinition.new(source_file, 1..3)
 
-    expect(definition_one).to eq(definition_two)
-  end
+      expect(definition_one).to eq(definition_two)
+    end
 
-  it 'has same hash as another method definition with same path and line numbers' do
-    definition_one = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
-    definition_two = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
+    it 'has same hash as another method definition with same path and line numbers' do
+      definition_one = MethodDefinition.new(source_file, 1..3)
+      definition_two = MethodDefinition.new(source_file, 1..3)
 
-    expect(definition_one.hash).to eq(definition_two.hash)
-  end
+      expect(definition_one.hash).to eq(definition_two.hash)
+    end
 
-  it 'provides access to the method source' do
-    definition = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
+    it 'provides access to the method source' do
+      definition = MethodDefinition.new(source_file, 1..3)
 
-    expect(definition.source).to eq(%{  def bar\n    # implementation\n  end})
+      expect(definition.source).to eq(source_file.snippet(1..3))
+    end
   end
-end
+end

data/spec/method_diff_spec.rb

@@ -1,13 +1,17 @@
+require 'spec_helper'
+
 require 'method_log/method_diff'
 
-describe MethodLog::MethodDiff do
-  let(:first_commit) { double(:first_commit) }
-  let(:second_commit) { double(:second_commit) }
-  let(:diff) { MethodLog::MethodDiff.new(first_commit: first_commit, second_commit: second_commit) }
+module MethodLog
+  describe MethodDiff do
+    let(:first_commit) { double(:first_commit) }
+    let(:second_commit) { double(:second_commit) }
+    let(:diff) { MethodDiff.new(first_commit, second_commit) }
 
-  it 'generates text diff of the method source for two commits' do
-    first_commit.stub(:method_source).and_return(%{line 1\nline 2\n})
-    second_commit.stub(:method_source).and_return(%{line 2\nline 3\n})
-    expect(diff.to_s).to eq(%{-line 1\n line 2\n+line 3\n})
+    it 'generates text diff of the method source for two commits' do
+      first_commit.stub(:method_source).and_return(%{line 1\nline 2\n})
+      second_commit.stub(:method_source).and_return(%{line 2\nline 3\n})
+      expect(diff.to_s).to eq(%{-line 1\n line 2\n+line 3\n})
+    end
   end
-end
+end

data/spec/method_finder_spec.rb

@@ -3,249 +3,245 @@ require 'spec_helper'
 require 'method_log/source_file'
 require 'method_log/method_finder'
 
-describe MethodLog::MethodFinder do
-  it 'finds definition of instance method on class' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  def bar
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo#bar')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 1..3))
-  end
-
-  it 'finds definition of instance method on module' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  def bar
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo#bar')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 1..3))
-  end
-
-  it 'finds definition of instance method on class within module' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  class Bar
-    def baz
-      # implementation
+module MethodLog
+  describe MethodFinder do
+    it 'finds definition of instance method on class' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+          def bar
+            # implementation
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo#bar')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 1..3))
     end
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::Bar#baz')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 2..4))
-  end
-
-  it 'finds definition of instance method on namespaced class within previously defined module' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-end
-
-class Foo::Bar
-  def baz
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::Bar#baz')
 
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 4..6))
-  end
+    it 'finds definition of instance method on module' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          def bar
+            # implementation
+          end
+        end
+      })
 
-  it 'finds definition of instance method on namespaced module within previously defined module' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-end
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo#bar')
 
-module Foo::Bar
-  def baz
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::Bar#baz')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 4..6))
-  end
-
-  it 'finds definition of class method on class' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  def self.bar
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.bar')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 1..3))
-  end
-
-  it 'finds definition of class method on class with explicit reference to class' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  def Foo.bar
-    # implementation
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.bar')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 1..3))
-  end
-
-  it 'finds definition of class method on class with explicit reference to namespaced class' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  class Bar
-    def (Foo::Bar).baz
-      # implementation
+      expect(method_definition).to eq(MethodDefinition.new(foo, 1..3))
     end
-  end
-end
-    }.strip)
-
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::Bar.baz')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 2..4))
-  end
-
-  it 'finds definition of class method on class with explicit reference to namespaced class outside current scope' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-end
-
-class Bar
-  def Foo.baz
-    # implementation
-  end
-end
-    }.strip)
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.baz')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 4..6))
-  end
-
-  it 'finds definition of class method on class when singleton class is re-opened' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  class << self
-    def bar
-      # implementation
+    it 'finds definition of instance method on class within module' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          class Bar
+            def baz
+              # implementation
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::Bar#baz')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 2..4))
     end
-  end
-end
-    }.strip)
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.bar')
-
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 2..4))
-  end
-
-  it 'finds definition of class method on class when singleton class is re-opened with explicit reference to class' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  class << Foo
-    def bar
-      # implementation
+    it 'finds definition of instance method on namespaced class within previously defined module' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+        end
+        class Foo::Bar
+          def baz
+            # implementation
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::Bar#baz')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 3..5))
     end
-  end
-end
-    }.strip)
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.bar')
+    it 'finds definition of instance method on namespaced module within previously defined module' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+        end
+        module Foo::Bar
+          def baz
+            # implementation
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::Bar#baz')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 3..5))
+    end
 
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 2..4))
-  end
+    it 'finds definition of class method on class' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          def self.bar
+            # implementation
+          end
+        end
+      })
 
-  it 'finds definition of class method on class when singleton class is re-opened with explicit reference to class outside current scope' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-end
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.bar')
 
-class Bar
-  class << Foo
-    def bar
-      # implementation
+      expect(method_definition).to eq(MethodDefinition.new(foo, 1..3))
     end
-  end
-end
-    }.strip)
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo.bar')
+    it 'finds definition of class method on class with explicit reference to class' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          def Foo.bar
+            # implementation
+          end
+        end
+      })
 
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 5..7))
-  end
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.bar')
 
-  it 'finds definition of class method on unknown object when singleton class is re-opened' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  def initialize
-    @foo = new
-    class << @foo
-      def bar
-        # implementation
-      end
+      expect(method_definition).to eq(MethodDefinition.new(foo, 1..3))
     end
-  end
-end
-    }.strip)
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::(ivar :@foo).bar')
+    it 'finds definition of class method on class with explicit reference to namespaced class' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          class Bar
+            def (Foo::Bar).baz
+              # implementation
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::Bar.baz')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 2..4))
+    end
 
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 4..6))
-  end
+    it 'finds definition of class method on class with explicit reference to namespaced class outside current scope' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+        end
+        class Bar
+          def Foo.baz
+            # implementation
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.baz')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 3..5))
+    end
 
-  it 'finds definition of class method on ambiguous module referenced via top-level module' do
-    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-module Foo
-  class Bar; end
-end
+    it 'finds definition of class method on class when singleton class is re-opened' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+          class << self
+            def bar
+              # implementation
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.bar')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 2..4))
+    end
 
-module Baz
-  module Foo
-    class Bar; end
-  end
+    it 'finds definition of class method on class when singleton class is re-opened with explicit reference to class' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+          class << Foo
+            def bar
+              # implementation
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.bar')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 2..4))
+    end
 
-  def (::Foo::Bar).foo
-    # implementation
-  end
-end
-    }.strip)
+    it 'finds definition of class method on class when singleton class is re-opened with explicit reference to class outside current scope' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+        end
+        class Bar
+          class << Foo
+            def bar
+              # implementation
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo.bar')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 4..6))
+    end
 
-    method_finder = MethodLog::MethodFinder.new(source_file: foo)
-    method_definition = method_finder.find('Foo::Bar.foo')
+    it 'finds definition of class method on unknown object when singleton class is re-opened' do
+      foo = source(path: 'foo.rb', source: %{
+        class Foo
+          def initialize
+            @foo = new
+            class << @foo
+              def bar
+                # implementation
+              end
+            end
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::(ivar :@foo).bar')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 4..6))
+    end
 
-    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 9..11))
+    it 'finds definition of class method on ambiguous module referenced via top-level module' do
+      foo = source(path: 'foo.rb', source: %{
+        module Foo
+          class Bar; end
+        end
+        module Baz
+          module Foo
+            class Bar; end
+          end
+          def (::Foo::Bar).foo
+            # implementation
+          end
+        end
+      })
+
+      method_finder = MethodFinder.new(foo)
+      method_definition = method_finder.find('Foo::Bar.foo')
+
+      expect(method_definition).to eq(MethodDefinition.new(foo, 7..9))
+    end
   end
 end