method_log 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8806c3155ef8119ce8144d2de6224cb9ec8c4cfb
-  data.tar.gz: 223707b63c5ee375fc0a6735cd9a04a85361952a
+  metadata.gz: 8416c62e1edaaecff55eca789a8480abee33ed7e
+  data.tar.gz: e1a5011e4329bf97b0115bdaf95cf56107042b00
 SHA512:
-  metadata.gz: 88c75c7ba8f9f1fe97257c873200c5e793c32a62060b1b01a4016c665b85ad3f4f8924f772903aebf0b8506cd2c701aaa90f757d1c04796184b2f005182a4524
-  data.tar.gz: c1306ec22ca0401966bc6d66a5ebb695bde5acd85016b1edcf6f95922901a29822333c83055d868e61db2b1c1c6c7600bda9928df5e2c7e76c7a39d1ab02aefa
+  metadata.gz: d221a1bf23774b980ef1b54869e1beca1ec9eac6a98e5fa628235c63e122658ec5f0667beb2ab3536945fd52b0e0d97dd3c59e5288d2f2c0b777d38e3b310a60
+  data.tar.gz: 787efa546b545eb8376f515d58b98d4161a53dc57a22d17157bae60b481d74ee05c44b4014a5f1499c6685a6defa0c9855067b5f2955467abf930ebfbbedf3bf

data/README.md

@@ -21,22 +21,24 @@ This is a work-in-progress and nowhere near production-ready.
 ### Todo
 
 * Support earlier versions of Ruby (it ought to be possible to support down to v1.9.3 fairly easily)
-* Support class methods
-* Support namespaced classes e.g. `class Foo::Bar`
+* Support absolute namespaces e.g. `class ::Foo::Bar`
 * Support for Rspec tests
-* Display diffs in method implementation between commits
-* Only display diffs when method implementation has changed
-* Default to looking for git repo in current working directory
 * Default to looking for commits in current git branch
 * Maybe add as new git command or extension to existing command e.g. `git log`
 * Optimise search for method definitions:
+  * Only consider commits where file that last contained method has changed
   * First look in file where method was last defined
   * Simple text search for files containing method name to narrow files that need to be parsed
+* Find "similar" method implementations e.g. by comparing ASTs of implementations
 
 ### Credits
 
 Written by [James Mead](http://jamesmead.org) and the other members of [Go Free Range](http://gofreerange.com).
 
+Thanks to Michael Feathers for some ideas in [delta-flora](https://github.com/michaelfeathers/delta-flora).
+
+Thanks to [TICOSA](http://ticosa.org/) for giving me the impetus to do something about an idea I'd been kicking around for a while.
+
 ### License
 
 Released under the [MIT License](https://github.com/freerange/method_log/blob/master/LICENSE).

data/bin/method_log

@@ -7,7 +7,13 @@ require 'method_log/api'
 
 repository = MethodLog::Repository.new(path: Dir.pwd)
 api = MethodLog::API.new(repository: repository)
-method_commits = api.history(ARGV[0])
-method_commits.each do |method_commit|
-  puts method_commit
+api.diffs(ARGV[0]).each do |method_commit, method_diff|
+  puts "commit #{method_commit.sha}"
+  puts "Author: #{method_commit.author[:name]} <#{method_commit.author[:email]}>"
+  puts "Date:   #{method_commit.author[:time].strftime('%a %b %-e %T %Y %z')}"
+  puts
+  puts method_commit.message
+  puts
+  puts method_diff.to_s(:color)
+  puts
 end

data/lib/method_log/api.rb

@@ -1,5 +1,6 @@
 require 'method_log/method_finder'
 require 'method_log/method_commit'
+require 'method_log/method_diff'
 
 module MethodLog
   class API
@@ -8,12 +9,25 @@ module MethodLog
     end
 
     def history(method_identifier)
-      @repository.commits.map do |commit|
-        method_definitions = commit.source_files.inject([]) do |definitions, source_file|
-          method_finder = MethodFinder.new(source_file: source_file)
-          definitions += Array(method_finder.find(method_identifier))
+      Enumerator.new do |yielder|
+        @repository.commits.each do |commit|
+          method_definitions = commit.source_files.inject([]) do |definitions, source_file|
+            method_finder = MethodFinder.new(source_file: source_file)
+            definitions += Array(method_finder.find(method_identifier))
+          end
+          yielder << MethodCommit.new(commit: commit, method_definition: method_definitions.first)
+        end
+      end
+    end
+
+    def diffs(method_identifier)
+      Enumerator.new do |yielder|
+        history(method_identifier).each_cons(2) do |(commit, parent)|
+          diff = MethodDiff.new(commit: commit, parent: parent)
+          unless diff.empty?
+            yielder << [commit, diff]
+          end
         end
-        MethodCommit.new(commit: commit, method_definition: method_definitions.first)
       end
     end
   end

data/lib/method_log/commit.rb

@@ -17,24 +17,32 @@ module MethodLog
       @index.add(path: source_file.path, oid: oid, mode: 0100644)
     end
 
-    def apply
+    def apply(user: { email: 'test@example.com', name: 'test', time: Time.now }, message: 'commit-message')
       tree = @index.write_tree(@repository)
       parents = @repository.empty? ? [] : [@repository.head.target].compact
-      user = { email: 'test@example.com', name: 'test', time: Time.now }
-      @sha = Rugged::Commit.create(@repository, tree: tree, parents: parents, update_ref: 'HEAD', author: user, committer: user, message: 'commit-message')
+      @sha = Rugged::Commit.create(@repository, tree: tree, parents: parents, update_ref: 'HEAD', author: user, committer: user, message: message)
     end
 
     def source_files
-      commit = @repository.lookup(sha)
       source_files = []
       commit.tree.walk_blobs do |root, blob_hash|
-        path = root.empty? ? blob_hash[:name] : File.join(root, blob_hash[:name])
+        name = blob_hash[:name]
+        next unless File.extname(name) == '.rb'
+        path = root.empty? ? name : File.join(root, name)
         source = @repository.lookup(blob_hash[:oid]).text
         source_files << SourceFile.new(path: path, source: source)
       end
       source_files
     end
 
+    def author
+      commit.author
+    end
+
+    def message
+      commit.message
+    end
+
     def ==(other)
       sha == other.sha
     end
@@ -46,5 +54,11 @@ module MethodLog
     def to_s
       sha
     end
+
+    private
+
+    def commit
+      @commit ||= @repository.lookup(sha)
+    end
   end
 end

data/lib/method_log/method_commit.rb

@@ -13,8 +13,20 @@ module MethodLog
       [commit, method_definition].hash
     end
 
-    def to_s
-      "#{commit}: #{method_definition}"
+    def sha
+      commit.sha
+    end
+
+    def author
+      commit.author
+    end
+
+    def message
+      commit.message
+    end
+
+    def method_source
+      method_definition && method_definition.source + $/
     end
 
     protected

data/lib/method_log/method_definition.rb

@@ -13,11 +13,8 @@ module MethodLog
       [source_file, lines].hash
     end
 
-    def to_s
-      [
-        "#{source_file.path}:#{lines}",
-        source_file.snippet(lines)
-      ].join($/)
+    def source
+      source_file.snippet(lines)
     end
 
     protected

data/lib/method_log/method_diff.rb

@@ -0,0 +1,17 @@
+require 'diffy'
+
+module MethodLog
+  class MethodDiff
+    def initialize(commit: nil, parent: nil)
+      @commit, @parent = commit, parent
+    end
+
+    def to_s(mode = :text)
+      Diffy::Diff.new(@commit.method_source, @parent.method_source).to_s(mode)
+    end
+
+    def empty?
+      to_s.chomp.empty?
+    end
+  end
+end

data/lib/method_log/method_finder.rb

@@ -1,51 +1,90 @@
-require 'ripper'
+require 'parser/current'
 
 require 'method_log/method_definition'
+require 'method_log/scope'
 
 module MethodLog
-  class MethodFinder < Ripper
+  class MethodFinder < Parser::AST::Processor
     def initialize(source_file: nil)
-      super(source_file.source)
       @source_file = source_file
-      @namespaces = []
+      @scope = Scope::Root.new
       @methods = {}
-      @at_scope_start = false
-      parse
+      ast = Parser::CurrentRuby.parse(source_file.source)
+      process(ast)
     end
 
     def find(method_identifier)
       @methods[method_identifier]
     end
 
-    def on_kw(name)
-      case name
-      when 'def'
-        @line_number = lineno
-      when 'class', 'module'
-        @at_scope_start = true
+    def on_module(node)
+      const_node = node.children.first
+      constants = process_const(const_node)
+      new_constant = constants.pop
+      with_scope(@scope.for(constants).define(new_constant)) { super }
+    end
+
+    alias_method :on_class, :on_module
+
+    def on_sclass(node)
+      target_node = node.children.first
+      with_scope(singleton_scope_for(target_node)) { super }
+    end
+
+    def on_def(node)
+      name, args_node, body_node = *node
+      record_method_definition(@scope, name, node)
+      super
+    end
+
+    def on_defs(node)
+      definee_node, name, args_node, body_node = *node
+      scope = singleton_scope_for(definee_node)
+      record_method_definition(scope, name, node)
+      super
+    end
+
+    private
+
+    def singleton_scope_for(node)
+      case node.type
+      when :self
+        @scope.singleton
+      when :const
+        constants = process_const(node)
+        @scope.for(constants).singleton
+      else
+        @scope.define(node.inspect).singleton
       end
     end
 
-    def on_const(name)
-      if @at_scope_start
-        @namespaces << name
-        @at_scope_start = false
+    def process_const(node, namespaces = [])
+      scope_node, name = *node
+      namespaces.unshift(name)
+      if scope_node
+        process_const(scope_node, namespaces)
       end
+      namespaces
     end
 
-    def on_def(name, *args)
-      identifier = "#{@namespaces.join('::')}##{name}"
-      lines = (@line_number - 1)..(lineno - 1)
-      definition = MethodDefinition.new(source_file: @source_file, lines: lines)
-      @methods[identifier] = definition
+    def lines_for(node)
+      expression = node.location.expression
+      first_line = expression.line - 1
+      last_line = expression.source_buffer.decompose_position(expression.end_pos).first - 1
+      first_line..last_line
     end
 
-    def on_class(*args)
-      @namespaces.pop
+    def record_method_definition(scope, name, node)
+      definition = MethodDefinition.new(source_file: @source_file, lines: lines_for(node))
+      identifier = scope.method_identifier(name)
+      @methods[identifier] = definition
     end
 
-    def on_module(*args)
-      @namespaces.pop
+    def with_scope(scope, &block)
+      @scope = scope
+      yield
+    ensure
+      @scope = scope.parent
     end
   end
 end

data/lib/method_log/scope.rb

@@ -0,0 +1,69 @@
+module MethodLog
+  class Scope
+    class Null < Scope
+      def initialize
+        super(name: 'null')
+      end
+
+      def lookup(name)
+        nil
+      end
+    end
+
+    class Root < Scope
+      def initialize
+        super(name: 'root', parent: Scope::Null.new)
+      end
+
+      def names
+        []
+      end
+    end
+
+    attr_reader :parent
+
+    def initialize(name: nil, parent: nil, singleton: false)
+      @name = name
+      @parent = parent
+      @singleton = singleton
+      @modules = {}
+    end
+
+    def for(modules)
+      scope = self
+      modules.each do |mod|
+        scope = scope.lookup(mod) || scope.define(mod)
+      end
+      scope
+    end
+
+    def define(name)
+      @modules[name] = Scope.new(name: name, parent: self)
+    end
+
+    def lookup(name)
+      @modules.fetch(name) { @parent.lookup(name) }
+    end
+
+    def singleton
+      Scope.new(name: @name, parent: self, singleton: true)
+    end
+
+    def method_identifier(name)
+      [names.join('::'), separator, name].join
+    end
+
+    protected
+
+    def names
+      names = @singleton ? [] : [@name]
+      names = @parent.names + names
+    end
+
+    private
+
+    def separator
+      @singleton ? '.' : '#'
+    end
+  end
+end

data/lib/method_log/version.rb

@@ -1,3 +1,3 @@
 module MethodLog
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/method_log.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_dependency 'rugged'
+  s.add_dependency 'parser'
+  s.add_dependency 'diffy'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'

data/spec/api_spec.rb

@@ -23,7 +23,7 @@ describe MethodLog::API do
     foo_1 = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
 class Foo
   def bar
-    # implementation
+    # implementation 1
   end
 end
     }.strip)
@@ -32,7 +32,7 @@ end
 # move method definition down one line
 class Foo
   def bar
-    # implementation
+    # implementation 2
   end
 end
     }.strip)
@@ -49,7 +49,7 @@ end
 
     repository = MethodLog::Repository.new(path: repository_path)
     api = MethodLog::API.new(repository: repository)
-    method_commits = api.history('Foo#bar')
+    method_commits = api.history('Foo#bar').to_a
 
     method_definition_1 = MethodLog::MethodDefinition.new(source_file: foo_1, lines: 1..3)
     method_definition_2 = MethodLog::MethodDefinition.new(source_file: foo_2, lines: 2..4)
@@ -58,5 +58,13 @@ end
     method_commit_2 = MethodLog::MethodCommit.new(commit: commit_2, method_definition: method_definition_2)
 
     expect(method_commits).to eq([method_commit_2, method_commit_1])
+    
+    method_commit, method_diff = api.diffs('Foo#bar').first
+    expect(method_diff.to_s.strip).to eq(%{
+   def bar
+-    # implementation 2
++    # implementation 1
+   end
+    }.strip)
   end
 end

data/spec/commit_spec.rb

@@ -41,5 +41,45 @@ describe MethodLog::Commit do
       commit = repository.commits.first
       expect(commit.source_files).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')
+
+      repository = MethodLog::Repository.new(path: repository_path)
+      commit = repository.build_commit
+      commit.add(source_file)
+      commit.apply
+
+      repository = MethodLog::Repository.new(path: repository_path)
+      commit = repository.commits.first
+      expect(commit.source_files).to be_empty
+    end
+
+    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')
+
+      repository = MethodLog::Repository.new(path: repository_path)
+      commit = repository.build_commit
+      commit.add(source_file)
+      commit.apply(user: user)
+
+      repository = MethodLog::Repository.new(path: 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')
+
+      repository = MethodLog::Repository.new(path: repository_path)
+      commit = repository.build_commit
+      commit.add(source_file)
+      commit.apply(message: 'commit-message')
+
+      repository = MethodLog::Repository.new(path: repository_path)
+      commit = repository.commits.first
+      expect(commit.message).to eq('commit-message')
+    end
   end
 end

data/spec/method_commit_spec.rb

@@ -5,8 +5,8 @@ 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: 'source') }
-  let(:method_definition) { MethodLog::MethodDefinition.new(source_file: source_file, lines: 5..7) }
+  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)
   }
@@ -21,4 +21,13 @@ describe MethodLog::MethodCommit do
   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 nil if no method definition' do
+    method_commit = MethodLog::MethodCommit.new(commit: commit, method_definition: nil)
+    expect(method_commit.method_source).to be_nil
+  end
 end

data/spec/method_definition_spec.rb

@@ -26,14 +26,9 @@ end
     expect(definition_one.hash).to eq(definition_two.hash)
   end
 
-  it 'describes method definition' do
+  it 'provides access to the method source' do
     definition = MethodLog::MethodDefinition.new(source_file: source_file, lines: 1..3)
 
-    expect(definition.to_s).to eq(%{
-  path/to/source.rb:1..3
-  def bar
-    # implementation
-  end
-    }.strip)
+    expect(definition.source).to eq(%{  def bar\n    # implementation\n  end})
   end
 end

data/spec/method_diff_spec.rb

@@ -0,0 +1,13 @@
+require 'method_log/method_diff'
+
+describe MethodLog::MethodDiff do
+  let(:commit) { double(:commit) }
+  let(:parent) { double(:parent) }
+  let(:diff) { MethodLog::MethodDiff.new(commit: commit, parent: parent) }
+
+  it 'generates text diff of the method source for two commits' do
+    commit.stub(:method_source).and_return(%{line 1\nline 2\n})
+    parent.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

data/spec/method_finder_spec.rb

@@ -50,4 +50,179 @@ end
 
     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 namespaced module within previously defined module' do
+    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
+module Foo
+end
+
+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
+    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
+    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
+    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 outside current scope' do
+    foo = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
+class Foo
+end
+
+class Bar
+  class << Foo
+    def bar
+      # implementation
+    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: 5..7))
+  end
+
+  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
+    end
+  end
+end
+    }.strip)
+
+    method_finder = MethodLog::MethodFinder.new(source_file: foo)
+    method_definition = method_finder.find('Foo::(ivar :@foo).bar')
+
+    expect(method_definition).to eq(MethodLog::MethodDefinition.new(source_file: foo, lines: 4..6))
+  end
 end

data/spec/scope_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+require 'method_log/scope'
+
+describe MethodLog::Scope do
+  let(:root) { MethodLog::Scope::Root.new }
+
+  it 'ruby interactive style method identifier for top-level module' do
+    a = root.define(:A)
+    expect(a.method_identifier('foo')).to eq('A#foo')
+  end
+
+  it 'ruby interactive style method identifier for module nested inside top-level module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    expect(b.method_identifier('foo')).to eq('A::B#foo')
+  end
+
+  it 'ruby interactive style method identifier for module nested inside module nested inside top-level module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    c = b.define(:C)
+    expect(c.method_identifier('foo')).to eq('A::B::C#foo')
+  end
+
+  it 'ruby interactive style method identifier for method on singleton class' do
+    a = root.define(:A)
+    singleton = a.singleton
+    expect(singleton.method_identifier('foo')).to eq('A.foo')
+  end
+
+  it 'ruby interactive style method identifier for method on singleton class nested inside top-level module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    singleton = b.singleton
+    expect(singleton.method_identifier('foo')).to eq('A::B.foo')
+  end
+
+  it 'looks up scope for top-level module' do
+    a = root.define(:A)
+    expect(a.lookup(:A)).to eq(a)
+  end
+
+  it 'looks up scopes for top-level module and nested module from nested module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    expect(b.lookup(:A)).to eq(a)
+    expect(b.lookup(:B)).to eq(b)
+  end
+
+  it 'looks up scopes for modules from double-nested module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    c = b.define(:C)
+    expect(c.lookup(:A)).to eq(a)
+    expect(c.lookup(:B)).to eq(b)
+    expect(c.lookup(:C)).to eq(c)
+  end
+
+  it 'looks up qualified module' do
+    a = root.define(:A)
+    b = a.define(:B)
+    c = b.define(:C)
+    expect(c.for([:A])).to eq(a)
+    expect(c.for([:A, :B])).to eq(b)
+    expect(c.for([:A, :B, :C])).to eq(c)
+  end
+
+  it 'defines missing modules' do
+    root.for([:A, :B, :C])
+    a = root.lookup(:A)
+    b = a.lookup(:B)
+    c = b.lookup(:C)
+    expect(a).not_to be_nil
+    expect(b).not_to be_nil
+    expect(c).not_to be_nil
+  end
+end
+

metadata

@@ -1,55 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: method_log
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - James Mead
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -60,8 +88,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -72,8 +100,10 @@ files:
 - lib/method_log/commit.rb
 - lib/method_log/method_commit.rb
 - lib/method_log/method_definition.rb
+- lib/method_log/method_diff.rb
 - lib/method_log/method_finder.rb
 - lib/method_log/repository.rb
+- lib/method_log/scope.rb
 - lib/method_log/source_file.rb
 - lib/method_log/version.rb
 - method_log.gemspec
@@ -93,7 +123,9 @@ files:
 - spec/commit_spec.rb
 - spec/method_commit_spec.rb
 - spec/method_definition_spec.rb
+- spec/method_diff_spec.rb
 - spec/method_finder_spec.rb
+- spec/scope_spec.rb
 - spec/source_file_spec.rb
 - spec/spec_helper.rb
 homepage: http://jamesmead.org
@@ -106,17 +138,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Trace the history of an individual method in a git repository.
@@ -125,6 +157,8 @@ test_files:
 - spec/commit_spec.rb
 - spec/method_commit_spec.rb
 - spec/method_definition_spec.rb
+- spec/method_diff_spec.rb
 - spec/method_finder_spec.rb
+- spec/scope_spec.rb
 - spec/source_file_spec.rb
 - spec/spec_helper.rb