git-autobisect 0.1.1 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    git-autobisect (0.1.1)
+    git-autobisect (0.2.0)
 
 GEM
   remote: http://rubygems.org/

data/Rakefile

@@ -3,3 +3,20 @@ require 'bundler/gem_tasks'
 task :default do
   sh "rspec spec/"
 end
+
+# extracted from https://github.com/grosser/project_template
+rule /^version:bump:.*/ do |t|
+  sh "git status | grep 'nothing to commit'" # ensure we are not dirty
+  index = ['major', 'minor','patch'].index(t.name.split(':').last)
+  file = 'lib/git/autobisect/version.rb'
+
+  version_file = File.read(file)
+  old_version, *version_parts = version_file.match(/(\d+)\.(\d+)\.(\d+)/).to_a
+  version_parts[index] = version_parts[index].to_i + 1
+  version_parts[2] = 0 if index < 2 # remove patch for minor
+  version_parts[1] = 0 if index < 1 # remove minor for major
+  new_version = version_parts * '.'
+  File.open(file,'w'){|f| f.write(version_file.sub(old_version, new_version)) }
+
+  sh "bundle && git add #{file} Gemfile.lock && git commit -m 'bump version to #{new_version}'"
+end

data/Readme.md

@@ -2,7 +2,7 @@ Find the first broken commit without having to learn git bisect.
 
  - automagically bundles if necessary
  - stops at first bad commit
- - starts slow (HEAD~1, HEAD~2, HEAD~3) then goes in steps of 10 (..., HEAD~10, HEAD~20, HEAD~30)
+ - takes binary steps (HEAD~1, HEAD~2, HEAD~4, HEAD~8)
 
 Install
 =======
@@ -19,10 +19,13 @@ Usage
     ---> The first bad commit is a4328fa
     git show
 
+### Options
+
+    -m, --max [N]                    Inspect commits between HEAD..HEAD~<max>
+
 TODO
 ====
- - go with 1 2 4 8 16 16 16 16 commits back
- - option for max-step -> if you think the problem is very fresh/very old
+ - option for max-step-size so you can use a finer grained approach
  - option to disable `bundle check || bundle` injection
  - option to consider a build failed if it finishes faster then x seconds
 

data/bin/git-autobisect

@@ -1,94 +1,5 @@
 #! /usr/bin/env ruby
-
-require 'rubygems'
 require 'optparse'
-
-OptionParser.new do |opts|
-  opts.banner = <<BANNER
-Find the commit that broke the build
-
-Usage:
-    git-autobisect 'ruby test/foo_test.rb -n "/xxx/"' [options]
-
-Options:
-BANNER
-  opts.on("-h", "--help","Show this.") { puts opts; exit }
-  opts.on("-v", "--version","Show Version"){
-    version = File.read(File.expand_path("../../VERSION", __FILE__))
-    puts "git-autobisect #{version}"; exit
-  }
-end.parse!
-
-command = ARGV.first
-if command.to_s.empty?
-  puts "Usage instructions: git-autobisect --help"
-  exit
-end
-
-def run(cmd)
-  all = ""
-  puts cmd
-  IO.popen(cmd) do |pipe|
-    while str = pipe.gets
-      all << str
-      puts str
-    end
-  end
-  [$?.success?, all]
-end
-
-def run!(command)
-  raise "Command failed #{command}" unless run(command).first
-end
-
-def find_first_good_commit(commits, command)
-  # scan backwards through commits to find a good
-  i = 0
-  stay_slow_until = 3
-
-  loop do
-    # pick next commit (start slow, then get faster)
-    i += 1
-    offset = (i <= stay_slow_until ? i-1 : (i-1)*10)
-    break unless commit = commits[offset]
-
-    # see if it works
-    puts " ---> Now trying #{commit}"
-    run!("git checkout #{commit}")
-    return commit if run(command).first
-  end
-end
-
-command = "(bundle check || bundle) && (#{command})" if File.exist?("Gemfile")
-puts " ---> Initial run:"
-if run(command).first
-  puts " ---> Current commit is not broken"
-  exit 1
-end
-
-puts " ---> Trying to find first good commit:"
-max_commits = 1000
-commits = `git log --pretty=format:'%h' | head -n #{max_commits}`.split("\n")
-unless good = find_first_good_commit(commits[1..-1], command)
-  puts " --> No good commit found"
-  exit 1
-end
-
-# bisect to get exact match
-bad = commits[0]
-run! "git bisect reset"
-run! "git bisect start"
-run! "git checkout #{bad}"
-run! "git bisect bad"
-run! "git checkout #{good}"
-run! "git bisect good"
-success, output = run("git bisect run sh -c '#{command}'")
-if success
-  # git bisect randomly stops at a commit
-  first_bad = output.match(/([\da-f]+) is the first bad commit/)[1]
-  run! "git checkout #{first_bad}"
-  exit 0
-else
-  exit 1
-end
-
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'git/autobisect'
+exit Git::Autobisect.cli(ARGV)

data/git-autobisect.gemspec

@@ -1,8 +1,8 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 name = "git-autobisect"
-version = File.read(File.expand_path("../VERSION", __FILE__))
+require "git/autobisect/version"
 
-Gem::Specification.new name, version do |s|
+Gem::Specification.new name, Git::Autobisect::Version do |s|
   s.summary = "Find the first broken commit without having to learn git bisect"
   s.authors = ["Michael Grosser"]
   s.email = "michael@grosser.it"

data/lib/git/autobisect.rb

@@ -0,0 +1,116 @@
+require "git/autobisect/version"
+
+module Git
+  module Autobisect
+    class << self
+      def cli(argv)
+        options = extract_options(argv)
+
+        command = argv.first
+        if command.to_s.empty?
+          puts "Usage instructions: git-autobisect --help"
+          return 1
+        end
+
+        command = "(bundle check || bundle) && (#{command})" if File.exist?("Gemfile")
+
+        run_command(command, options) || 0
+      end
+
+      def run_command(command, options)
+        commits = `git log --pretty=format:'%h' | head -n #{options[:max]}`.split("\n")
+        good, bad = find_good_and_bad_commit(commits, command)
+
+        if good == commits.first
+          puts " ---> HEAD is not broken"
+          return 1
+        elsif not good
+          puts " ---> No good commit found before HEAD~#{options[:max]}"
+          return 1
+        end
+
+        if exact_commit_known?(commits, good, bad)
+          # return same result as git bisect
+          run! "git checkout #{bad}"
+          puts "#{bad} is the first bad commit"
+          puts `git show #{bad}`
+        else
+          first_bad = bisect_to_exact_match(command, good, bad)
+          run! "git checkout #{first_bad}"
+        end
+      end
+
+      private
+
+      def extract_options(argv)
+        options = {
+          :max => 1000
+        }
+        OptionParser.new do |opts|
+          opts.banner = <<-BANNER.gsub(" "*12, "")
+            Find the commit that broke the build
+
+            Usage:
+                git-autobisect 'ruby test/foo_test.rb -n "/xxx/"' [options]
+
+            Options:
+          BANNER
+          opts.on("-h", "--help", "Show this.") { puts opts; exit }
+          opts.on("-v", "--version", "Show Version"){ puts "git-autobisect #{Version}"; exit }
+          opts.on("-m", "--max [N]", Integer, "Inspect commits between HEAD..HEAD~<max>"){|max| options[:max] = max }
+        end.parse!(argv)
+        options
+      end
+
+      def run(cmd)
+        all = ""
+        puts cmd
+        IO.popen(cmd) do |pipe|
+          while str = pipe.gets
+            all << str
+            puts str
+          end
+        end
+        [$?.success?, all]
+      end
+
+      def run!(command)
+        raise "Command failed #{command}" unless run(command).first
+      end
+
+      def find_good_and_bad_commit(commits, command)
+        i = 0
+        maybe_good = commits.first
+
+        loop do
+          # scan backwards through commits to find a good
+          offset = [2**i - 1, commits.size-1].min
+          maybe_good, bad = commits[offset], maybe_good
+          return if i > 0 and bad == maybe_good # we reached the end
+
+          # see if it works
+          puts " ---> Now trying #{maybe_good} (HEAD~#{offset})"
+          run!("git checkout #{maybe_good}")
+          return [maybe_good, bad] if run(command).first
+          i += 1
+        end
+      end
+
+      def bisect_to_exact_match(command, good, bad)
+        run! "git bisect reset"
+        run! "git bisect start"
+        run! "git checkout #{bad}"
+        run! "git bisect bad"
+        run! "git checkout #{good}"
+        run! "git bisect good"
+        success, output = run("git bisect run sh -c '#{command}'")
+        raise "error while bisecting" unless success
+        output.match(/([\da-f]+) is the first bad commit/)[1]
+      end
+
+      def exact_commit_known?(commits, good, bad)
+        (commits.index(good) - commits.index(bad)).abs <= 1
+      end
+    end
+  end
+end

data/lib/git/autobisect/version.rb

@@ -0,0 +1,5 @@
+module Git
+  module Autobisect
+    VERSION = Version = "0.2.0"
+  end
+end

data/spec/git-autobisect_spec.rb

@@ -16,8 +16,8 @@ describe "git-autobisect" do
     run "git log --oneline | head -1"
   end
 
-  def add_irrelevant_commit(name)
-    run "touch #{name} && git add #{name} && git commit -m 'added #{name}'"
+  def add_irrelevant_commit(name="b")
+    run "echo #{rand} >> #{name} && git add #{name} && git commit -m 'added #{name}'"
   end
 
   def remove_a
@@ -30,7 +30,7 @@ describe "git-autobisect" do
 
   describe "basics" do
     it "shows its usage without arguments" do
-      autobisect("").should include("Usage")
+      autobisect("", :fail => true).should include("Usage")
     end
 
     it "shows its usage with -h" do
@@ -58,22 +58,47 @@ describe "git-autobisect" do
     end
 
     it "stops when the first commit works" do
-      autobisect("'test 1'", :fail => true).should include("Current commit is not broken")
+      autobisect("'test 1'", :fail => true).should include("HEAD is not broken")
     end
 
     it "stops when no commit works" do
       autobisect("test", :fail => true).should include("No good commit found")
     end
 
+    context "--max" do
+      let(:command){ "'test -e a' --max 5" }
+
+      it "finds if a commit works inside of max range" do
+        remove_a
+        3.times{ add_irrelevant_commit }
+        autobisect(command).should_not include("No good commit found")
+      end
+
+      it "stops when no commit works inside of max range" do
+        remove_a
+        5.times{ add_irrelevant_commit }
+        autobisect(command, :fail => true).should include("No good commit found")
+      end
+    end
+
     it "finds the first broken commit for 1 commit" do
       remove_a
       result = autobisect("'test -e a'")
-      result.should include("bisect run success")
+      result.should_not include("bisect run")
+      result.should =~ /is the first bad commit.*remove a/m
+    end
+
+    it "finds the first broken commit for multiple commits" do
+      remove_a
+      result = autobisect("'test -e a'")
+      result.should_not include("bisect run success")
       result.should =~ /is the first bad commit.*remove a/m
     end
 
     it "can run a complex command" do
+      10.times{ add_irrelevant_commit }
       remove_a
+      10.times{ add_irrelevant_commit }
       result = autobisect("'sleep 0.01 && test -e a'")
       result.should include("bisect run success")
       result.should =~ /is the first bad commit.*remove a/m
@@ -126,8 +151,7 @@ describe "git-autobisect" do
         result = autobisect("'echo a >> count && test -e a'")
         result.should include("bisect run success")
         result.should include("added e")
-        result.should_not include("added d")
-        File.read('count').count('a').should == 6
+        File.read('count').count('a').should == 4
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-autobisect
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2012-10-06 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: michael@grosser.it
@@ -23,9 +23,10 @@ files:
 - Gemfile.lock
 - Rakefile
 - Readme.md
-- VERSION
 - bin/git-autobisect
 - git-autobisect.gemspec
+- lib/git/autobisect.rb
+- lib/git/autobisect/version.rb
 - spec/git-autobisect_spec.rb
 homepage: http://github.com/grosser/git-autobisect
 licenses:
@@ -42,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2753072243294133809
+      hash: -1063815506089341293
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -51,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2753072243294133809
+      hash: -1063815506089341293
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/VERSION

@@ -1 +0,0 @@
-0.1.1