git-trac 0.0.20071102

data/lib/git/trac/runner.rb

@@ -0,0 +1,303 @@
+require 'optparse'
+require 'ostruct'
+
+module Git
+  module Trac
+
+    def self.run(argv)
+      Runner.new(argv)
+    end
+
+    class Runner
+
+      attr_reader :options
+
+      def initialize(argv)
+        @argv = argv.dup
+        run
+      rescue Git::Trac::Error
+        $stderr.puts "Error: " + $!.message
+        exit 1
+      end
+
+      def abort(message)
+        raise Git::Trac::Error, message
+      end
+
+      def general_usage
+        $stderr.puts <<-EOS
+Usage: git-trac <command> [options] [arguments]
+
+Available commands:
+        cleanup         Remove old branches for a ticket
+        download        Download all patches for a ticket to the cwd
+        fetch           Create brances for all patches of a ticket
+        show            Show a summary of a ticket
+        upload-patch    Upload the current diff against trunk to a ticket
+        EOS
+        exit 1
+      end
+
+      def run
+
+        command = @argv.shift
+        repo = nil
+        if command == "--repository"
+          repo, command = @argv.shift, @argv.shift
+        end
+
+        if command == "help"
+          command = @argv.shift
+          @argv.unshift "--help"
+        end
+        general_usage unless command
+
+        @repository = Git::Trac::Repository.new(repo)
+        unless @repository.url || @argv.first == "--help"
+          abort "no URL.  Try `git config trac.url http://trac-url`"
+        end
+
+        klass_name = command.capitalize.gsub(/-(.)/) { $1.upcase }
+        if self.class.const_defined?(klass_name)
+          klass = self.class.const_get(klass_name)
+          if klass < Base
+            return klass.new(@argv, @repository)
+          end
+        end
+
+        general_usage
+
+      end
+
+      class Base
+
+        attr_reader :options
+
+        def initialize(argv, repo)
+          @argv, @repository = argv, repo
+          @options = {}
+          @opts = OptionParser.new
+          @opts.banner = "Usage: git-trac #{command} #{banner_arguments}\n#{"\n" if description}#{description}"
+          @opts.separator("")
+          add_options(@opts)
+          begin
+            @opts.parse!(@argv)
+          rescue OptionParser::InvalidOption
+            abort $!.message
+          end
+          run
+        end
+
+        def description
+        end
+
+        def get_ticket_number
+          if @argv.first =~ /^\d+$/
+            Integer(@argv.shift)
+          elsif number = @repository.guess_current_ticket_number
+            number
+          elsif block_given?
+            yield
+          else
+            abort "ticket number required"
+          end
+        end
+
+        def require_ticket_number
+          @opts.separator("Ticket number is required unless it can be derived from the current branch.\n")
+        end
+
+        def abort(message)
+          $stderr.puts "Error: #{message}"
+          # $stderr.puts @opts
+          exit(1)
+        end
+
+        def add_options(opts)
+        end
+
+        def banner_arguments
+          "[options]"
+        end
+
+        def command
+          self.class.name[/[^:]*$/].gsub(/(.)([A-Z])/) { $1+"-"+$2 }.downcase
+        end
+
+      end
+
+      class Download < Base
+
+        def description
+          <<-EOF
+Download all attachments that look like patches to the current working
+directory.
+          EOF
+        end
+
+        def banner_arguments
+          "[options] [ticket]"
+        end
+
+        def add_options(opts)
+          require_ticket_number
+          opts.separator("Options:")
+          opts.on("--filter PATTERN","only download patches matching PATTERN") do |pattern|
+            options[:filter] = pattern
+          end
+        end
+
+        def run
+          number = get_ticket_number
+          @repository.ticket(number).attachments.each do |attach|
+            next if options[:filter] && attach.filename !~ /#{options[:filter]}/
+            File.open(attach.filename, "w") do |f|
+              f.puts attach.body
+            end
+          end
+        end
+
+      end
+
+      class Show < Base
+
+        def banner_arguments
+          "[ticket]"
+        end
+
+        def description
+          <<-EOF
+Show a crude ticket summary.
+          EOF
+        end
+
+        def add_options(opts)
+          require_ticket_number
+        end
+
+        def run
+          number = get_ticket_number
+          csv = @repository.ticket(number).csv
+          csv.reject {|k,v| k == "description"}.sort.each do |(k,v)|
+            puts "#{k}: #{v}" if v
+          end
+          puts "description:"
+          puts csv["description"]
+        end
+
+      end
+
+      class Fetch < Base
+
+        def banner_arguments
+          "[ticket]"
+        end
+
+        def description
+          <<-EOF
+Download all branches that look like patches.  For each patch, find the
+revision of trunk that most recently proceeds the the time of upload, apply
+the patch to it, create a new commit, and add a remote head of the form
+refs/remotes/trac/ticketnumber/file_name_ext.  Patches with the same root
+name (filename.diff, filename.2.diff, filename.patch, etc.) will committed in
+parent child relationships based on upload time.  This means filename.2.diff
+might cite filename.diff as a parent.  For each root name, a branch is created
+pointing to the newest patch.  Existing branches will not be overridden, but
+there is an implied `git cleanup <patch>` that runs beforehand which could
+potentially remove conflicted branches first.
+          EOF
+        end
+
+        def add_options(opts)
+          require_ticket_number
+        end
+
+        def run
+          number = get_ticket_number
+          @repository.ticket(number).fetch do |attachment, branch|
+            if branch
+              puts "#{attachment.filename}: #{branch}"
+            else
+              $stderr.puts "#{attachment.filename} FAILED"
+            end
+          end
+        end
+
+      end
+
+      class Cleanup < Base
+
+        def banner_arguments
+          "[options] [ticket] [ticket] ..."
+        end
+
+        def description
+          <<-EOF
+Remove remote heads for a given ticket (e.g., trac/12345/work_patch).  Also
+removes branches that point to one of these heads.  Branches that have been
+committed to will not be removed.  The default is to target tickets that have
+been closed, but you can also specify ticket numbers explicitly or use --all.
+          EOF
+        end
+
+        def add_options(opts)
+          opts.separator("Options:")
+          opts.on("-a","--all", "cleanup all tickets") { options[:all] = true }
+        end
+
+        def run
+          if options[:all]
+            @repository.working_tickets.each do |t|
+              t.cleanup
+            end
+          elsif @argv.any?
+            begin
+              @argv.each do |a|
+                @repository.ticket(Integer(a)).cleanup
+              end
+            rescue TypeError
+              abort "invalid ticket number"
+            end
+          else
+            @repository.working_tickets.each do |t|
+              t.cleanup unless t.open?
+            end
+          end
+        end
+      end
+
+      class UploadPatch < Base
+
+        def banner_arguments
+          "[options] [ticket]"
+        end
+
+        def description
+          <<-EOF
+Do a `git diff` against trunk (or another branch) and upload the result as an
+attachment to a ticket.  This command is experimental to take care when using
+it against a production trac server.
+          EOF
+        end
+
+        def add_options(opts)
+          require_ticket_number
+          opts.on("--branch BRANCH", "git diff BRANCH (default trunk)") do |b|
+            options[:branch] = b
+          end
+        end
+
+        def run
+          number = get_ticket_number
+          if uri = @repository.ticket(number).upload_patch(options)
+            puts uri
+          else
+            exit 1
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/git/trac/ticket.rb

@@ -0,0 +1,183 @@
+require 'hpricot'
+require 'fileutils'
+
+module Git
+  module Trac
+
+    class Ticket
+
+      attr_reader :repository, :number
+
+      def initialize(repo, number)
+        @repository, @number = repo, Integer(number)
+      end
+
+      def inspect
+        "#<#{self.class.inspect} #{url}>"
+      end
+
+      def url(format = nil)
+        query = "?format=#{format}" if format
+        "#{@repository.url}/ticket/#{@number}#{query}"
+      end
+
+      def attachment_url
+        "#{@repository.url}/attachment/ticket/#{@number}"
+      end
+
+      def csv
+        require 'net/http'
+        require 'uri'
+        body = Net::HTTP.get_response(URI.parse(url(:tab))).body
+        headers, values = body.split(/\r?\n/).map do |line|
+          line.split("\t").map do |column|
+            column.gsub(/\\(.)/) do
+              case $1
+              when "r" then ""
+              when "n" then "\n"
+              when "t" then "\t"
+              else $1
+              end
+            end
+          end
+        end
+        return headers.zip(values).inject({}) {|h,(k,v)| h[k] = v; h}
+      end
+
+      attr_reader :number
+
+      def attachments(&block)
+        entries = repository.agent.get(attachment_url).at("dl.attachments")
+        require 'git/trac/attachment'
+        Attachment.from_hpricot(self,entries)
+      end
+
+      def trac_dir
+        "#{repository.git_dir}/refs/remotes/trac/#{number}"
+      end
+
+      class Form
+        def initialize(mech_form)
+          @mech_form = mech_form
+        end
+
+        def submit(*args)
+          @mech_form.submit
+        end
+
+        def method_missing(method,*args,&block)
+          if method.to_s[-1] == "=" && @mech_form.fields.name(method.to_s[0..-2]).any?
+            @mech_form.fields.name(method.to_s[0..-2]).send(:value=,*args,&block)
+          elsif @mech_form.fields.name(method.to_s).any?
+            @mech_form.fields.name(method.to_s).send(:value,*args,&block)
+          else
+            super(method,*args,&block)
+          end
+        end
+      end
+
+      def form
+        repository.agent.get(url).forms.last
+      end
+
+      def comment!(body)
+        form = form()
+        form.fields.name("comment").value = body
+        form.submit
+      end
+
+      def upload_attachment(description, filename, body)
+        form = repository.agent.get("#{attachment_url}?action-new").forms.last
+        author = form.fields.name("author")
+        if author.any? && author.value == "anonymous"
+          author.value = repository.options[:user].to_s
+        end
+        form.fields.name("description").value = description.to_s
+        attachment = form.file_uploads.name("attachment").first
+        attachment.file_name = filename
+        attachment.file_data = body
+        form.submit.instance_variable_get(:@uri)
+      end
+
+      def upload_patch(options = {})
+        filename = options[:filename] || "#{File.basename(repository.current_checkout)}.patch"
+        # diff = repository.exec("git-diff","#{options[:branch] || "trunk"}...HEAD")
+        diff = repository.exec("git-diff", options[:branch] || "trunk")
+        return false if diff.empty?
+        # Don't upload the exact same patch that was pulled down
+        return false if repository.generated_commits[repository.rev_parse("HEAD")] == number
+        upload_attachment(options[:description], filename, diff)
+      end
+
+      def open?
+        c = csv
+        %w(new reopened).include?(c["status"])
+      end
+
+      def cleanup
+        revs = []
+        repository.each_ref("refs/remotes/trac/#{number}") do |object, ref|
+          revs << object
+          repository.exec("git-update-ref","-d",ref,object)
+        end
+        unless revs.empty?
+          repository.each_ref("refs/heads") do |object, ref|
+            if revs.include?(object) && repository.current_checkout != File.basename(ref)
+              repository.exec("git-branch","-D",File.basename(ref))
+            end
+          end
+          true
+        end
+      end
+
+      def fetch(options = {})
+        cleanup
+        seen = {}
+        repository.with_index("tracindex#{$$}") do
+          FileUtils.mkdir_p(trac_dir)
+          attachments.map do |attachment|
+            parent = repository.exec("git-rev-list","--max-count=1","--before=#{attachment.timestamp}",options[:branch] || 'trunk').chomp
+            repository.exec("git-read-tree",parent)
+            unless attachment.apply!
+              yield attachment, false if block_given?
+              next
+            end
+            tree = repository.exec("git-write-tree").chomp
+            ENV["GIT_AUTHOR_NAME"] = ENV["GIT_COMMITTER_NAME"] = attachment.username
+            ENV["GIT_AUTHOR_EMAIL"] = ENV["GIT_COMMITTER_EMAIL"] = attachment.email
+            ENV["GIT_AUTHOR_DATE"] = ENV["GIT_COMMITTER_DATE"] = attachment.timestamp
+            if repeated = seen[attachment.name]
+              if repeated.last == parent
+                parents = " -p #{repeated.first}"
+              else
+                parents = " -p #{repeated.first} -p #{parent}"
+              end
+            else
+              parents = " -p #{parent}"
+            end
+            commit = repository.popen3("git-commit-tree #{tree}#{parents}") do |i,o,e|
+              i.puts attachment.description || attachment.filename
+              i.close
+              o.read.chomp
+            end
+            File.open(attachment.tag_path,"w") do |f|
+              f.puts commit
+            end
+            yield attachment, attachment.tag_name if block_given?
+            seen[attachment.name] = [commit, parent]
+            commit
+          end
+        end
+        seen.each do |k,v|
+          if !File.exists?(path = "#{repository.git_dir}/refs/heads/#{k}")
+            File.open(path, "w") {|f| f.puts v.first}
+          end
+        end
+      ensure
+        %w(GIT_AUTHOR_NAME GIT_COMMITTER_NAME GIT_AUTHOR_EMAIL GIT_COMMITTER_EMAIL GIT_AUTHOR_DATE GIT_COMMITTER_DATE).each {|e| ENV[e] = nil}
+      end
+
+    end
+
+  end
+end