method_log 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41e9aab264b13fe45d2a9647bf235cea14ea5378
-  data.tar.gz: 15fd978c654b949dc848f1c91057d6a104f008b8
+  metadata.gz: 8e04ff3b961b6a3955ede7783834922849c7e959
+  data.tar.gz: 36bd0e165bbba5bb13cdabef4110709d80e42921
 SHA512:
-  metadata.gz: 6d077e6eb40d283f0f490e0420a2650f29a6eb8382e38ab36c6ab8551c6fe88fccc6f087d6eed70851ee4749f88e5c6fdb1889c98380076a02ba568daf0d05f8
-  data.tar.gz: 7dd0f4d2191b7e83b9d9b483f1452c0cde6af6f0cd5ee8e30e0395d2a88fa623a1c25c48f819a2077031657fff3bdd21bb7825983e82b4fa9343d69f13c1c83f
+  metadata.gz: 54e9280555d0f24e5fc215351c81a92889b502604e314caad19f6f6a72e891e10dc029e716fbc2100e76737f7f2998540eb95dbcc99d12ec88874e7e80588c87
+  data.tar.gz: ebba91b228114666d7b69ab73eb7a4e089b03eb60b4b00503da92a6c4313fce0e7f101ad14ee4d6cbf94d9152c0407c101cd3abfdcf25101a0f9cc7cfd0ee46f

data/.travis.yml

@@ -2,4 +2,5 @@ language: ruby
 rvm:
   - 2.1.0
   - 2.0.0
+  - 1.9.3
 

data/README.md

@@ -4,11 +4,12 @@ Trace the history of an individual method in a git repository.
 
 This is a work-in-progress and nowhere near production-ready.
 
-### Dependencies
+### Requirements
 
-* Ruby >= v2.0.0 (just because I'm using named parameters)
+* Ruby >= v1.9.3 (due to requirements of the `rugged` gem)
 * The [rugged](https://github.com/libgit2/rugged) Ruby gem (listed as dependency in gemspec)
 * The [libgit2](https://github.com/libgit2/libgit2) C library (included as part of rugged gem)
+* The [parser](https://github.com/whitequark/parser) Ruby gem (listed as dependency in gemspec)
 
 ### Install
 
@@ -20,15 +21,12 @@ 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)
-* Investigate whether parser gem can only parse source code written using the current Ruby version
-  * It would be nice to have a better error message if parsing fails
 * Support for Rspec tests
 * Default to looking for commits in current git branch
+* Check what happens with merge commits
 * Maybe add as new git command or extension to existing command e.g. `git log`
 * Optimise search for method definitions:
   * First look in file where method was last defined
-* By default stop when method disappears from history
 * Find "similar" method implementations e.g. by comparing ASTs of implementations
 
 ### Credits

data/bin/method_log

@@ -1,19 +1,35 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'method_log'
-require 'method_log/repository'
-require 'method_log/api'
 require 'trollop'
 
 options = Trollop::options do
   opt :patch, 'Generate patch.', short: 'p'
+  opt :ruby_version, 'Parser Ruby version (18, 19, 20, 21)', default: 'current'
   opt :max_count, 'Limit the number of commits to output.', type: :integer, short: 'n'
+  opt :stop_at_latest_introduction_of_method, 'Stop at lastest introduction of method.', default: true
+end
+
+case ruby_version = options[:ruby_version]
+when 'current'
+  require 'parser/current'
+when '18', '19', '20', '21'
+  require 'parser/ruby18'
+  require 'parser/ruby19'
+  require 'parser/ruby20'
+  require 'parser/ruby21'
+  Parser::CurrentRuby = Parser.const_get("Ruby#{ruby_version}")
+else
+  raise "Ruby version not supported: #{ruby_version}"
 end
 
-repository = MethodLog::Repository.new(path: Dir.pwd)
-api = MethodLog::API.new(repository: repository)
-api.diffs(ARGV[0], max_count: options[:max_count]).each do |method_commit, method_diff|
+require 'method_log'
+require 'method_log/repository'
+require 'method_log/api'
+
+repository = MethodLog::Repository.new(Dir.pwd)
+api = MethodLog::API.new(repository)
+api.diffs(ARGV[0], options).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')}"

data/lib/method_log/api.rb

@@ -4,31 +4,32 @@ require 'method_log/method_diff'
 
 module MethodLog
   class API
-    def initialize(repository: nil)
+    def initialize(repository)
       @repository = repository
     end
 
-    def history(method_identifier, max_count: nil)
-      method_name = method_identifier.split(Regexp.union('#', '.')).last
+    def history(method_identifier, options = {})
       Enumerator.new do |yielder|
-        last_source_file = nil
-        @repository.commits(max_count: max_count).each do |commit|
-          next if last_source_file && commit.contains?(last_source_file)
-          source_files = commit.source_files.select { |sf| sf.source[Regexp.new(method_name)] }
-          method_definition = nil
-          source_files.map { |sf| MethodFinder.new(source_file: sf) }.each do |method_finder|
-            break if method_definition = method_finder.find(method_identifier)
+        last_method_commit = nil
+        @repository.commits(options).each do |commit|
+          last_source_file = last_method_commit && last_method_commit.source_file
+          if last_source_file && commit.contains?(last_source_file)
+            last_method_commit.update(commit)
+          else
+            method_definition = commit.find(method_identifier)
+            yielder << last_method_commit if last_method_commit
+            last_method_commit = MethodCommit.new(commit, method_definition)
+            yielder << last_method_commit
+            break if options[:stop_at_latest_introduction_of_method] && method_definition.nil?
           end
-          last_source_file = method_definition && method_definition.source_file
-          yielder << MethodCommit.new(commit: commit, method_definition: method_definition)
         end
       end
     end
 
-    def diffs(method_identifier, max_count: nil)
+    def diffs(method_identifier, options = {})
       Enumerator.new do |yielder|
-        history(method_identifier, max_count: max_count).each_cons(2) do |(commit, parent)|
-          diff = MethodDiff.new(first_commit: parent, second_commit: commit)
+        history(method_identifier, options).each_cons(2) do |(commit, parent)|
+          diff = MethodDiff.new(parent, commit)
           unless diff.empty?
             yielder << [commit, diff]
           end

data/lib/method_log/commit.rb

@@ -6,7 +6,7 @@ module MethodLog
   class Commit
     attr_reader :sha
 
-    def initialize(repository: nil, sha: nil)
+    def initialize(sha, repository = nil)
       @repository = repository
       @sha = sha
       @index = Rugged::Index.new
@@ -17,7 +17,8 @@ module MethodLog
       @index.add(path: source_file.path, oid: oid, mode: 0100644)
     end
 
-    def apply(user: { email: 'test@example.com', name: 'test', time: Time.now }, message: 'commit-message')
+    def apply(options = {})
+      user, message = options[:user], options[:message]
       tree = @index.write_tree(@repository)
       parents = @repository.empty? ? [] : [@repository.head.target].compact
       @sha = Rugged::Commit.create(@repository, tree: tree, parents: parents, update_ref: 'HEAD', author: user, committer: user, message: message)
@@ -38,6 +39,17 @@ module MethodLog
       source_files_by_path[source_file.path] == source_file
     end
 
+    def find(method_identifier)
+      method_definition = nil
+      method_name = method_identifier.split(Regexp.union('#', '.')).last
+      source_files.each do |source_file|
+        next unless source_file.source[Regexp.new(method_name)]
+        method_finder = MethodFinder.new(source_file)
+        break if method_definition = method_finder.find(method_identifier)
+      end
+      method_definition
+    end
+
     def author
       commit.author
     end

data/lib/method_log/method_commit.rb

@@ -1,10 +1,16 @@
 module MethodLog
   class MethodCommit
-    def initialize(commit: nil, method_definition: nil)
+    attr_reader :method_definition
+
+    def initialize(commit, method_definition)
       @commit = commit
       @method_definition = method_definition
     end
 
+    def update(commit)
+      @commit = commit
+    end
+
     def ==(other)
       (commit == other.commit) && (method_definition == other.method_definition)
     end
@@ -29,9 +35,12 @@ module MethodLog
       method_definition && method_definition.source + $/
     end
 
+    def source_file
+      method_definition && method_definition.source_file
+    end
+
     protected
 
     attr_reader :commit
-    attr_reader :method_definition
   end
 end

data/lib/method_log/method_definition.rb

@@ -2,7 +2,7 @@ module MethodLog
   class MethodDefinition
     attr_reader :source_file
 
-    def initialize(source_file: nil, lines: nil)
+    def initialize(source_file, lines)
       @source_file = source_file
       @lines = lines
     end

data/lib/method_log/method_diff.rb

@@ -2,7 +2,7 @@ require 'diffy'
 
 module MethodLog
   class MethodDiff
-    def initialize(first_commit: nil, second_commit: nil)
+    def initialize(first_commit, second_commit)
       @first_commit, @second_commit = first_commit, second_commit
     end
 

data/lib/method_log/method_finder.rb

@@ -1,11 +1,13 @@
-require 'parser/current'
+unless defined?(Parser::CurrentRuby)
+  require 'parser/current'
+end
 
 require 'method_log/method_definition'
 require 'method_log/scope'
 
 module MethodLog
   class MethodFinder < Parser::AST::Processor
-    def initialize(source_file: nil)
+    def initialize(source_file)
       @source_file = source_file
       @scope = Scope::Root.new
       @methods = {}
@@ -76,7 +78,7 @@ module MethodLog
     end
 
     def record_method_definition(scope, name, node)
-      definition = MethodDefinition.new(source_file: @source_file, lines: lines_for(node))
+      definition = MethodDefinition.new(@source_file, lines_for(node))
       identifier = scope.method_identifier(name)
       @methods[identifier] = definition
     end

data/lib/method_log/repository.rb

@@ -4,26 +4,32 @@ require 'method_log/commit'
 
 module MethodLog
   class Repository
-    def initialize(path: nil)
+    def initialize(path)
       @repository = Rugged::Repository.new(path)
       @commits = []
     end
 
-    def build_commit(sha: nil)
-      Commit.new(repository: @repository, sha: sha)
+    def build_commit(sha = nil)
+      Commit.new(sha, @repository)
     end
 
-    def add(commit)
-      commit.apply
-      @commits << commit
+    def commit(*source_files)
+      options = source_files.pop if source_files.last.is_a?(Hash)
+      options ||= {}
+      options = { user: { email: 'test@example.com', name: 'test', time: Time.now }, message: 'commit-message' }.merge(options)
+      build_commit.tap do |commit|
+        source_files.each { |sf| commit.add(sf) }
+        commit.apply(options)
+        @commits << commit
+      end
     end
 
-    def commits(max_count: nil)
+    def commits(options = {})
       Enumerator.new do |yielder|
         if @repository.ref('refs/heads/master')
           @repository.walk(@repository.last_commit).with_index do |commit, index|
-            break if max_count && index >= max_count - 1
-            yielder << build_commit(sha: commit.oid)
+            break if options[:max_count] && index >= options[:max_count] - 1
+            yielder << build_commit(commit.oid)
           end
         end
       end

data/lib/method_log/scope.rb

@@ -2,7 +2,7 @@ module MethodLog
   class Scope
     class Null < Scope
       def initialize
-        super(name: 'null')
+        super('null')
       end
 
       def lookup(name)
@@ -12,7 +12,7 @@ module MethodLog
 
     class Root < Scope
       def initialize
-        super(name: 'root', parent: Scope::Null.new)
+        super('root', parent = Scope::Null.new)
       end
 
       def names
@@ -26,7 +26,7 @@ module MethodLog
 
     attr_reader :parent
 
-    def initialize(name: nil, parent: nil, singleton: false)
+    def initialize(name, parent = nil, singleton = false)
       @name = name
       @parent = parent
       @singleton = singleton
@@ -46,7 +46,7 @@ module MethodLog
     end
 
     def define(name)
-      @modules[name] = Scope.new(name: name, parent: self)
+      @modules[name] = Scope.new(name, parent = self)
     end
 
     def lookup(name)
@@ -54,7 +54,7 @@ module MethodLog
     end
 
     def singleton
-      Scope.new(name: @name, parent: self, singleton: true)
+      Scope.new(@name, parent = self, singleton = true)
     end
 
     def method_identifier(name)

data/lib/method_log/source_file.rb

@@ -3,11 +3,11 @@ module MethodLog
     attr_reader :path
     attr_reader :sha
 
-    def initialize(path: nil, source: nil, repository: nil, sha: nil)
-      @path = path
-      @source = source
-      @repository = repository
-      @sha = sha
+    def initialize(options = {})
+      @path = options[:path]
+      @source = options[:source]
+      @repository = options[:repository]
+      @sha = options[:sha]
     end
 
     def source

data/lib/method_log/version.rb

@@ -1,3 +1,3 @@
 module MethodLog
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/method_log.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.required_ruby_version = '>= 1.9.3'
+
   s.add_dependency 'rugged'
   s.add_dependency 'parser'
   s.add_dependency 'diffy'

data/spec/api_spec.rb

@@ -7,99 +7,87 @@ require 'method_log/commit'
 require 'method_log/method_definition'
 require 'method_log/method_commit'
 
-describe MethodLog::API 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
-
-  after do
-    FileUtils.rm_rf(repository_path)
-  end
-
-  it 'finds class instance method in repository with two commits with single source file' do
-    foo_1 = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  def bar
-    # implementation 1
-  end
-end
-    }.strip)
-
-    foo_2 = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-# move method definition down one line
-class Foo
-  def bar
-    # implementation 2
-  end
-end
-    }.strip)
-
-    repository = MethodLog::Repository.new(path: repository_path)
-
-    commit_1 = repository.build_commit
-    commit_1.add(foo_1)
-    repository.add(commit_1)
-
-    commit_2 = repository.build_commit
-    commit_2.add(foo_2)
-    repository.add(commit_2)
-
-    repository = MethodLog::Repository.new(path: repository_path)
-    api = MethodLog::API.new(repository: repository)
-    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)
-
-    method_commit_1 = MethodLog::MethodCommit.new(commit: commit_1, method_definition: method_definition_1)
-    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 1
-+    # implementation 2
-   end
-    }.strip)
-  end
-
-  it 'finds method which is defined in one commit, then removed in the next commit, and defined again in the next commit' do
-    foo_with_bar = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-  def bar; end
-end
-    }.strip)
-
-    foo_without_bar = MethodLog::SourceFile.new(path: 'foo.rb', source: %{
-class Foo
-end
-    }.strip)
-
-    repository = MethodLog::Repository.new(path: repository_path)
-
-    commit_1 = repository.build_commit
-    commit_1.add(foo_with_bar)
-    repository.add(commit_1)
-
-    commit_2 = repository.build_commit
-    commit_2.add(foo_without_bar)
-    repository.add(commit_2)
-
-    commit_3 = repository.build_commit
-    commit_3.add(foo_with_bar)
-    repository.add(commit_3)
-
-    repository = MethodLog::Repository.new(path: repository_path)
-    api = MethodLog::API.new(repository: repository)
-    diffs = api.diffs('Foo#bar').map(&:last).map(&:to_s)
-    expect(diffs).to eq([
-      "+  def bar; end\n",
-      "-  def bar; end\n"
-    ])
+module MethodLog
+  describe API 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
+
+    after do
+      FileUtils.rm_rf(repository_path)
+    end
+
+    it 'finds class instance method in repository with two commits with single source file' do
+      repository = Repository.new(repository_path)
+      commit_1 = repository.commit(source(path: 'foo.rb', source: %{
+        class Foo
+          def bar
+            # implementation 1
+          end
+        end
+      }))
+      commit_2 = repository.commit(source(path: 'foo.rb', source: %{
+        # move method definition down one line
+        class Foo
+          def bar
+            # implementation 2
+          end
+        end
+      }))
+
+      method_commits, method_diffs = commits_and_diffs_for('Foo#bar')
+
+      expect(method_commits.first.sha).to eq(commit_2.sha)
+      expect(method_diffs.first.to_s.chomp).to eq(unindent(%{
+           def bar
+        -    # implementation 1
+        +    # implementation 2
+           end
+      }))
+    end
+
+    it 'finds method which is defined, then removed, and then defined again' do
+      repository = Repository.new(repository_path)
+      commit_1 = repository.commit(source(path: 'foo.rb', source: %{
+        class Foo
+          def bar; end
+        end
+      }))
+      commit_2 = repository.commit(source(path: 'foo.rb', source: %{
+        class Foo
+        end
+      }))
+      commit_3 = repository.commit(source(path: 'foo.rb', source: %{
+        class Foo
+          def bar; end
+        end
+      }))
+      commit_4 = repository.commit(source(path: 'foo.rb', source: %{
+        class Foo
+          def bar; end
+        end
+      }))
+
+      method_commits, method_diffs = commits_and_diffs_for('Foo#bar')
+
+      expect(method_commits.map(&:sha)).to eq([commit_3.sha, commit_2.sha])
+      expect(method_diffs.map(&:to_s)).to eq([
+        "+  def bar; end\n",
+        "-  def bar; end\n"
+      ])
+    end
+
+    private
+
+    def commits_and_diffs_for(method_identifier)
+      api = API.new(Repository.new(repository_path))
+      commits_and_diffs = api.diffs(method_identifier)
+      method_commits = commits_and_diffs.map(&:first)
+      method_diffs = commits_and_diffs.map(&:last)
+      [method_commits, method_diffs]
+    end
   end
-end
+end