git-trac 0.0.20071102

data/README

@@ -0,0 +1,24 @@
+Run git-trac help for usage information.
+
+Example for usage on the Ruby on Rails repository:
+
+# Export the repository if you haven't already (start it and go to lunch)
+$ git-svn clone --stdlayout http://dev.rubyonrails.org/svn/rails rails
+$ cd rails
+
+# This next step is optional but compresses the repository by a factor of 10
+$ git gc
+
+# Setup git-trac (only URL is mandatory)
+$ git config trac.url http://dev.rubyonrails.org
+$ git config trac.username myaccount
+$ git config trac.password mypassword
+
+# Have fun
+$ git-trac download 1234567
+$ git branch
+$ git checkout some_attached_patch
+$ git rebase trunk # if it's out of date
+# EDIT EDIT EDIT
+$ git commit -a
+$ git-trac upload-patch 1234567

data/Rakefile

@@ -0,0 +1,109 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require 'rake/contrib/rubyforgepublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'git', 'trac')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'git-trac'
+PKG_VERSION   = Time.now.strftime("0.0.%Y%m%d")
+PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
+# PKG_DESTINATION = ENV["PKG_DESTINATION"] || "../#{PKG_NAME}"
+
+# RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = PKG_NAME
+RUBY_FORGE_USER    = "tpope"
+
+desc "Default task: test"
+task :default => [ :test ]
+
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.test_files = Dir['test/*_test.rb'] + Dir['test/test_*.rb']
+  t.verbose = true
+}
+
+
+# Generate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.rdoc_files.add('lib')
+  rdoc.main     = "Git::Trac"
+  rdoc.title    = rdoc.main
+  rdoc.options << '--inline-source'
+}
+
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = 'Interact with trac from a git repository pulled from svn'
+  s.description = 'git-trac takes the repetition out of working with trac and git-svn.  Among other features is the ability to easily attach a patch to a ticket and to pull all patches from a ticket and turn them into git branches.  Created for (but not limited to) work on the Ruby on Rails core.'
+  s.version = PKG_VERSION
+
+  s.author = 'Tim Pope'
+  s.email = 'ruby@tp0pe.inf0'.gsub(/0/,'o')
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.homepage = "http://#{PKG_NAME}.rubyforge.org"
+
+  s.has_rdoc = true
+  # s.requirements << 'none'
+  s.require_path = 'lib'
+
+  s.bindir = "bin"
+  s.executables = ["git-trac"]
+  s.default_executable = "git-trac"
+
+  s.add_dependency('mechanize', '>= 0.6.8')
+
+  s.files = [ "Rakefile", "README", "setup.rb" ]
+  s.files = s.files + Dir.glob( "lib/**/*.rb" )
+  s.files = s.files + Dir.glob( "test/**/*" ).reject { |item| item.include?( "\.svn" ) }
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+# Publish documentation
+desc "Publish the API documentation"
+task :pdoc => [:rerdoc] do 
+  # Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT,RUBY_FORGE_USER).upload
+  Rake::SshDirPublisher.new("rubyforge.org", "/var/www/gforge-projects/#{PKG_NAME}", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  `rubyforge login`
+
+  for ext in %w( gem tgz zip )
+    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}"
+    puts release_command
+    system(release_command)
+  end
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = Dir['test/*_test.rb'] + Dir['test/test_*.rb']
+    t.verbose = true
+    t.rcov_opts << "--text-report"
+    # t.rcov_opts << "--exclude \\\\A/var/lib/gems"
+    t.rcov_opts << "--exclude '/(active_record|active_support)\\b'"
+  end
+rescue LoadError
+end

data/bin/git-trac

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$:.unshift(File.join(File.dirname(File.dirname(__FILE__)),"lib"))
+
+require 'git/trac'
+
+Git::Trac.run(ARGV)

data/lib/git/trac.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+module Git
+  module Trac
+    class Error < ::RuntimeError
+    end
+    class ExecutionError < Error
+    end
+  end
+end
+
+require 'git/trac/repository'
+require 'git/trac/ticket'
+require 'git/trac/attachment'
+require 'git/trac/runner'

data/lib/git/trac/attachment.rb

@@ -0,0 +1,103 @@
+module Git
+  module Trac
+
+    class Attachment
+
+      attr_reader :ticket, :filename, :user, :time
+      attr_accessor :description
+
+      def initialize(ticket, filename, user, time)
+        @ticket, @filename, @user, @time = ticket, filename, user, time
+      end
+
+      def self.from_hpricot(ticket, html)
+        collection = []
+        return collection unless html
+        (html.children).each do |element|
+          if !element.elem?
+          elsif element.name == "dd"
+            str = ""
+            element.traverse_text {|t| str << t.to_s}
+            collection.last.description = str
+          elsif element.name = "dt"
+            texts = []
+            element.traverse_text {|x| texts << x.to_s}
+            if texts.first =~ /\A(\w*)(\.\d+)?\.(diff|patch)\Z/
+              time = Time.parse("#{texts[3]} +0000").utc
+              collection << new(ticket, texts[0], texts[2], time)
+            end
+          end
+        end
+        collection
+      end
+
+      def extension
+        File.extname(@filename)
+      end
+
+      def name
+        @filename[/^[^.]*/]
+      end
+
+      def number
+        @filename[/\.(\d+)\./,1]
+      end
+
+      def username
+        user.to_s[/[^\s@]+/]
+      end
+
+      def email
+        if user =~ /\S*@\S*/
+          return user
+        elsif user =~ /<(\S*@\S*)>/
+          return $1
+        else
+          [user, repository.url[%r{://([^/]*)},1]].compact.join("@")
+        end
+      end
+
+      def timestamp
+        time.utc.strftime("%Y-%m-%d_%H:%M:%S_+0000")
+      end
+
+      def url
+        "#{ticket.repository.url}/attachment/ticket/#{ticket.number}/#{filename}?format=raw"
+      end
+
+      def tag_name
+        "trac/#{ticket.number}/#{filename.gsub(/[^A-Za-z0-9]+/,"_")}"
+      end
+
+      def tag_path
+        "#{ticket.repository.git_dir}/refs/remotes/#{tag_name}"
+      end
+
+      def body
+        @body ||= repository.agent.get_file(url)
+      end
+
+      def p_level
+        if body[0,10] == "diff --git"
+          1
+        else
+          0
+        end
+      end
+
+      def repository
+        ticket.repository
+      end
+
+      def apply!
+        repository.popen3("git-apply", "-p#{p_level}", :cached => true, :whitespace => "nowarn") do |inn,out,err|
+          inn.puts body
+          inn.close
+          err.read.empty?
+        end
+      end
+
+    end
+
+  end
+end

data/lib/git/trac/repository.rb

@@ -0,0 +1,229 @@
+require 'open3'
+
+module Git
+  module Trac
+
+    class Repository
+
+      attr_reader :git_dir, :options
+
+      def initialize(dir = nil, options = {})
+        options, dir = dir, nil if dir.kind_of?(Hash)
+        dir ||= ENV["GIT_DIR"]
+        dir ||= Dir.getwd
+        @git_dir = Dir.chdir(dir) do
+          Open3.popen3("git","rev-parse","--git-dir") do |i,o,e|
+            e.read.empty? ? o.read.chomp("\n") : nil
+          end
+        end
+        raise Git::Trac::Error, "Not a git repository" unless @git_dir
+        @git_dir = File.join(".",@git_dir) if @git_dir[0] == ?~
+        @git_dir = File.expand_path(@git_dir)
+        @options = (config("trac")||{}).merge(options)
+        unless url
+          # raise Git::Trac::Error, "missing trac url: consider `git config trac.url http://tracurl`"
+        end
+      end
+
+      def inspect
+        "#<#{self.class.inspect} #{git_dir} #{url}>"
+      end
+
+      # Call the block while chdired to the working tree.
+      def in_work_tree(&block)
+        Dir.chdir(File.dirname(@git_dir),&block)
+      end
+
+      # Open3.popen3 in the current working tree.  An optional hash in the last
+      # argument is converted to flags that precede the arguments.
+      # <tt>:foo_bar => "baz"</tt> becomes <tt>--foo-bar=baz</tt>
+      def popen3(*args,&block)
+        args.flatten!
+        cmd = args.shift
+        if args.last.kind_of?(Hash)
+          args.pop.each do |k,v|
+            k = k.to_s.tr('-_','_-')
+            opt = case v
+                  when true  then "#{k}"
+                  when false then "no-#{k}"
+                  else            "#{k}=#{v}"
+                  end
+            args.unshift "--#{opt}"
+          end
+        end
+        in_work_tree { Open3.popen3(cmd,*args,&block) }
+      end
+
+      # Invokes a command.  If the command writes to stderr, said output is
+      # raised as an exception.  Otherwise, read from stdout and return it as a
+      # string.  If a block is given, each line is yielded to it.
+      def exec(*args,&block)
+        popen3(*args) do |i,o,e|
+          err = e.read
+          if err.empty?
+            if block_given?
+              o.each_line(&block)
+              nil
+            else
+              o.read
+            end
+          else
+            raise Git::Trac::ExecutionError, err.chomp
+          end
+        end
+      end
+
+      def method_missing(method,*args,&block)
+        if method.to_s =~ /^git_/
+          exec(method.to_s.tr('_-','-_'),*args, &block)
+        else
+          super(method,*args,&block)
+        end
+      end
+
+      # Call git-rev-parse on a revision, returning nil if nothing is found.
+      def rev_parse(rev)
+        if rev.kind_of?(String)
+          exec("git-rev-parse","--verify",rev).chomp
+        elsif rev.kind_of?(Array)
+          hash = {}
+          return hash if rev.empty?
+          exec("git-rev-parse",*rev) do |rev|
+            hash[name] = rev.chomp if rev.chomp =~ /^[0-9a-f]{40}$/
+          end
+          hash
+        end
+      end
+
+      def each_ref(*args)
+        pattern = args.empty? ? "refs" : args.join("/")
+        exec("git-for-each-ref", pattern, :format => "%(objectname) %(refname)") do |line|
+          yield *line.chomp.split(" ",2)
+        end
+      end
+
+      def current_checkout
+        contents = File.read("#{git_dir}/HEAD").chomp
+        if contents =~ %r{^ref: refs/heads/(.*)}
+          $1
+        else
+          contents
+        end
+      end
+
+      def with_index(file)
+        old_index = ENV["GIT_INDEX_FILE"]
+        ENV["GIT_INDEX_FILE"] = File.join(git_dir,file)
+        yield file
+      ensure
+        ENV["GIT_INDEX_FILE"] = old_index
+        File.unlink(file) rescue nil
+      end
+
+      # Parse the output of git-config and return it as a hash.
+      def config(arg1 = nil, arg2 = nil)
+        unless @config
+          @config = {}
+          exec("git-config","-l") do |line|
+            key, value = line.split("=",2)
+            superkey, subkey = key.match(/(.*)\.(.*)/).to_a[1,2]
+            @config[superkey] ||= {}
+            @config[superkey][subkey.tr('-_','_-').to_sym] = value
+            # hash[key] ||= []
+            # hash[key] << value
+            # @config[key] = value
+          end
+        end
+        if arg2
+          (@config[arg1.to_s]||{})[arg2.to_sym]
+        elsif arg1
+          @config[arg1]
+        else
+          @config
+        end
+      end
+
+      # The trac url associated with the repository.
+      def url
+        options[:url] || config("svn-remote.svn",:url).to_s[%r{(http://.*)/svn},1]
+      end
+
+      def agent
+        unless defined?(@agent)
+          require 'mechanize'
+          @agent = WWW::Mechanize.new {|a| a.log = nil}
+          url = "#{url}/login"
+          if options[:password]
+
+            begin
+              page = @agent.get(url)
+            rescue WWW::Mechanize::ResponseCodeError => e
+              # 401 Forbidden, let's try HTTP authentication
+              raise e unless e.response_code == "401"
+              @agent.basic_auth(options[:username],options[:password])
+              begin
+                page = @agent.get(url)
+                return @agent
+              rescue WWW::Mechanize::ResponseCodeError => e
+                raise e unless e.response_code == "401"
+                raise Git::Trac::Error, "invalid username or password"
+              end
+            end
+
+            # Form authentication
+            agent.redirect_ok = false
+            form = page.forms.last
+            form.fields.name("user").value = options[:username]
+            form.fields.name("password").value = options[:password]
+            form.action = url # Mechanize gets this wrong
+            begin
+              page = @agent.submit(form)
+              unless page.respond_to?(:code) && page.code == "303"
+                raise Git::Trac::Error, "invalid username or password"
+              end
+            ensure
+              agent.redirect_ok = true
+            end
+          end
+
+        end
+        @agent
+      end
+
+      # A hash of the form {commit_revision => ticket_number}
+      def generated_commits
+        hash = {}
+        each_ref("refs/remotes/trac") do |object, ref|
+          hash[object] = File.basename(File.dirname(ref)).to_i
+        end
+        hash
+      end
+
+      # See if the current commit or an ancestor was previously tagged as a
+      # trac ticket.  Also check git config branch.branchname.tracticket
+      def guess_current_ticket_number
+        if number = config("branch.#{current_checkout}", :tracticket)
+          return number.to_i
+        else
+          hash = generated_commits
+          exec("git-rev-list", "HEAD", :maxcount => 25) do |line|
+            number = hash[line.chomp] and return number
+          end
+          nil
+        end
+      end
+
+      # Fetch a ticket object by number.
+      def ticket(number)
+        Ticket.new(self, number)
+      end
+
+      # Return ticket objects for each ticket referenced in the repository.
+      def working_tickets
+        Dir.entries("#{git_dir}/refs/remotes/trac").map {|number| ticket(number.to_i) unless number.to_i.zero? }.compact
+      end
+
+    end
+
+  end
+end