git-trac 0.0.20080206 → 0.1.0

data/lib/git/trac/runner/apply.rb

@@ -4,8 +4,12 @@ module Git
 
       class Apply < Base #:nodoc:
 
+        def self.summary
+          "Apply a patch directly to the work tree"
+        end
+
         def banner_arguments
-          "[ticket[/filename]]"
+          "[<attachment>]"
         end
 
         def description
@@ -14,43 +18,35 @@ Apply a patch directly to the work tree.  This command is a building block used
 by other, more powerful commands and most users will never need to invoke it
 directly.
 
-The argument can be either a "ticket/filename" specifiying the patch to apply,
-or simply  ticket, in which case the tickets's last patch is applied.  If no
-argument is given, the patch is read from stdin.
-
 The --depth option specifies how many directories deep to recursively attempt
 to apply the patch in.  For a depth of 2, the patch will be attempted in the
-repositority root, foo, foo/bar, but not foo/baz.  It will also try stripping
-off up to 2 directories off of the paths inside the patch, the same as -p0,
--p1, and -p2 with patch(1).  The option is ignored if the patch appears to have
-been generated with git.  The default value is 0, but this can be changed with
-the trac.depth configuration option.
+repositority root, foo, foo/bar, but not foo/bar/baz.  It will also try
+stripping off up to 2 directories off of the paths inside the patch, the same
+as -p0, -p1, and -p2 with patch(1).  The option is ignored if the patch appears
+to have been generated with git.  The default value is 0, but this can be
+changed with the trac.depth configuration option.
 
 If the patch fails to apply even after a depth search, and the patch contains
 carriage returns, a second pass is made with those carriage returns stripped.
+
+If no argument is given, the patch is read from stdin.
           EOF
         end
 
         def add_options(opts)
-          require_ticket_number
           opts.on("--depth NUM","search NUM directories deep for a root") do |n|
             options[:depth] = n
           end
           opts.on("--root DIR","apply patches relative to DIR") do |dir|
             options[:root] = dir
           end
-          add_local_option(opts)
         end
 
         def run
           if @argv.empty?
-            patch = Patch.new(@repository,$stdin.read)
-          elsif @argv.size > 1
-            abort "too many arguments"
+            patch = Patch.new(repository,$stdin.read)
           else
-            each_ticket_argument do |number, filename|
-              patch = @repository.ticket(number).attachment(filename).patch
-            end
+            patch = one_attachment.patch
           end
           abort "no changes" if patch.body.empty?
           unless patch.apply(options)

data/lib/git/trac/runner/checkout.rb

@@ -0,0 +1,81 @@
+module Git
+  module Trac
+    class Runner
+
+      class Checkout < Base #:nodoc:
+
+        include Fetchable
+
+        def self.summary
+          "Fetch an attachment and check it out into a branch"
+        end
+
+        def banner_arguments
+          "[options] <attachment> [<branchname>]"
+        end
+
+        def description
+          <<-EOF
+Fetch the specified attachment and check it out into a new branch.  If no
+branch name is given, one is generated automatically from the attachment
+filename.
+
+If the branch already exists, it will be deleted if it contains either the same
+exact changes as the attachment, or no changes at all, with respect to
+upstream.
+          EOF
+        end
+
+        def add_options(opts)
+          @checkout_options = []
+          super
+          opts.on("--rebase","rebase after checkout") do
+            options[:rebase] = true
+          end
+          opts.on("-q","git checkout -q") do
+            @checkout_options << "-f"
+          end
+          opts.on("-f","git checkout -f") do
+            @checkout_options << "-f"
+          end
+          opts.on("-m","git checkout -m") do
+            @checkout_options << "-m"
+          end
+        end
+
+        def run
+          options[:upstream] ||= repository.guess_upstream || "refs/remotes/trunk"
+          fetch_unless_local
+          attachment = one_attachment(false)
+          branch = @argv.shift || attachment.name
+          too_many_arguments if @argv.any?
+          fetch_or_abort(attachment)
+
+          to_be_deleted = nil
+          repository.each_ref("refs/heads/#{branch}") do |object,ref|
+            hash = repository.diff_hash(object)
+            if hash == Digest::SHA1.digest("") || hash == repository.diff_hash(attachment.tag_name)
+              to_be_deleted = "#{branch}_tmp_git-trac_#{$$}"
+              repository.exec("git","branch","-m",branch,to_be_deleted)
+            end
+          end
+
+          repository.in_work_tree do
+            unless Kernel.system("git","checkout",*@checkout_options + ["-b",branch,attachment.tag_name])
+              exitstatus = $?.exitstatus
+              if to_be_deleted
+                repository.exec("git","branch","-m",to_be_deleted,branch)
+              end
+              exit exitstatus
+            end
+          end
+
+          repository.exec("git","branch","-D",to_be_deleted) if to_be_deleted
+          system("git","rebase",options[:upstream]) if options[:rebase]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/git/trac/runner/cleanup.rb

@@ -4,13 +4,17 @@ module Git
 
       class Cleanup < Base #:nodoc:
 
+        def self.summary
+          "Remove old branches for a ticket"
+        end
+
         def banner_arguments
-          "[options] [ticket[/filename]] ..."
+          "[options] [<attachment>...]"
         end
 
         def description
           <<-EOF
-Remove remote heads for a given ticket (e.g., trac/12345/work_patch).  Also
+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.
@@ -18,22 +22,27 @@ been closed, but you can also specify ticket numbers explicitly or use --all.
         end
 
         def add_options(opts)
-          opts.separator("Options:")
           opts.on("-a","--all", "cleanup all tickets") { options[:all] = true }
+          opts.on("--only-branches", "cleanup branches only, not remote heads") do |b|
+            options[:only_branches] = true
+          end
+          opts.on("--[no-]rebased","also cleanup rebased attachments") do |b|
+            options[:rebased] = b
+          end
         end
 
         def run
           if options[:all]
-            @repository.working_tickets.each do |t|
-              t.cleanup
+            repository.working_tickets.each do |t|
+              t.cleanup(options)
             end
           elsif @argv.any?
-            each_ticket_argument do |number, filename|
-              @repository.ticket(number).cleanup(:attachment => filename)
+            each_ticket_or_attachment do |ticket_or_attachment|
+              ticket_or_attachment.cleanup(options)
             end
           else
-            @repository.working_tickets.each do |t|
-              t.cleanup unless t.open?
+            repository.working_tickets.each do |t|
+              t.cleanup(options) unless t.open?
             end
           end
         end

data/lib/git/trac/runner/fetch.rb

@@ -4,54 +4,60 @@ module Git
 
       class Fetch < Base #:nodoc:
 
+        include Fetchable
+
+        def self.summary
+          "Create remote heads for ticket attachments"
+        end
+
         def banner_arguments
-          "[options] [ticket[/filename]] ..."
+          "<attachment>..."
         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.
-
-For each unique base name (filename without extension), 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 conflicting branches first.  Automatic branch creation is
-informally deprecated and may be removed in a future release.
+For each attachment argument, find the revision that most recently preceeds 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/filename.ext.
+
+If the --auto-branch option is given, a unique branch is created for each
+unique base name (filename without extension) of each attachment.  If multiple
+attachments have the same base name, the newest is used.  Existing branches
+will not be overridden, but there is an implied `git cleanup` that runs
+beforehand which could potentially remove conflicting branches first.
+Automatic branch creation used to be the default, but now the behavior is
+deprecated and may be removed in a future release.  Consider using `git-trac
+checkout` instead.
           EOF
         end
 
         def add_options(opts)
-          require_ticket_number
-          opts.on("--branch BRANCH","apply against branch BRANCH") do |b|
-            options[:branch] = b
-          end
-          opts.on("--depth NUM","search depth (see git-trac help apply)") do |n|
-            options[:depth] = n
+          super
+          opts.on("--auto-branch","create branches for attachments") do
+            options[:auto_branch] = true
           end
-          opts.on("--root DIR","apply patches relative to DIR") do |dir|
-            options[:root] = dir
-          end
-          add_local_option(opts)
         end
 
         def run
           fetch_unless_local
-          each_ticket_argument do |number, filename|
-            loop_opts = options.dup
-            if filename
-              loop_opts[:filter] = "\\A#{Regexp.escape(filename)}"
-            end
-            @repository.ticket(number).fetch(loop_opts) do |attachment, dir|
-              if dir == "."
+          each_ticket_or_attachment do |ticket|
+            seen = {}
+            ticket.fetch(options) do |attachment, dir, commit|
+              if dir == "." || dir == true
                 puts "#{attachment.tag_name}"
               elsif dir
                 puts "#{attachment.tag_name} (#{dir})"
               else
                 $stderr.puts "#{attachment.tag_name} FAILED"
               end
+              seen[attachment.name] = commit if commit
+            end
+            if options[:auto_branch]
+              seen.each do |k,v|
+                if !File.exists?(path = "#{repository.git_dir}/refs/heads/#{k}")
+                  File.open(path, "w") {|f| f.puts v}
+                end
+              end
             end
           end
         end

data/lib/git/trac/runner/help.rb

@@ -0,0 +1,141 @@
+module Git
+  module Trac
+    class Runner
+
+      class Help < Base #:nodoc:
+
+        def self.summary
+          "Help for a command or topic"
+        end
+
+        def banner_arguments
+          "[<command> | --commands | <topic> | --topics]"
+        end
+
+        def add_options(opts)
+          @options = {} # Don't try to read the repository config
+          opts.on("--commands","list all commands") do |commands|
+            options[:commands] = commands
+          end
+          opts.on("--topics","list all topics") do |topics|
+            options[:topics] = topics
+          end
+        end
+
+        def description
+          <<-EOF
+Show help for a given topic or command.
+          EOF
+        end
+
+        def commands
+          Runner.commands.map do |runner|
+            [runner.command, runner.summary]
+          end
+        end
+
+        def topics
+          TOPICS.keys.compact.sort.map do |key|
+            [key, TOPICS[key].first]
+          end
+        end
+
+        def run
+          topic = @argv.first
+          if options[:commands]
+            puts commands.map {|t| "%-15s %s\n" % t}.join
+          elsif options[:topics]
+            puts topics.map {|t| "%-15s %s\n" % t}.join
+          elsif !topic
+            Pager.new.page(default)
+          elsif klass = Runner.for_command(topic)
+            return klass.new(["--help"],nil)
+          elsif TOPICS[topic]
+            body = TOPICS[topic].last
+            body = body.call(self) if body.respond_to?(:call)
+            Pager.new.page(body)
+          else
+            abort "no such topic #{topic}"
+          end
+        end
+
+        def default
+          out = "Usage: git-trac <command> [options] [arguments]\n"
+          out << "\nCommands:\n"
+          out << commands.map {|t| "        %-15s %s\n" % t}.join
+          out << "\nHelp topics:\n"
+          out << topics.map {|t| "        %-15s %s\n" % t}.join
+          out << "\nUse git-trac help <command> or git-trac help <topic> for further information.\n"
+        end
+
+        TOPICS = {}
+
+        TOPICS["config"] = ["Configuration"] << <<-EOF
+The following configuration options control git-trac:
+  trac.url            The root URL to the Trac website
+  trac.username       Username (if required by site)
+  trac.password       Password (if required by site)
+  trac.depth          Default --depth for commands which accept it
+  trac.fetch-command  Update command to use in lieu of git svn fetch
+
+They may be set either by editing the git config file or with git config.
+  $ vim .git/config
+  $ git config trac.url http://my.trac.url
+
+Additionally, the following options can affect git-trac's behavior:
+  core.pager
+  color.diff
+  color.pager
+
+Tip: `git-trac` can be called as `git trac` with the following alias:
+  $ git config alias.trac '!git-trac'
+        EOF
+
+        TOPICS["rails"] = ["Quick start guide for Rails"] << <<-EOF
+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 (see git-trac help config)
+  $ git config trac.url http://dev.rubyonrails.org
+  $ git config trac.username myaccount
+  $ git config trac.password mypassword
+
+  # Have fun
+  $ git-trac checkout 1234567/new_feature_with_failing_tests.patch
+  $ rake
+  $ git-trac checkout --rebase 1234567/new_feature_with_passing_tests.patch
+  # EDIT EDIT EDIT
+  $ git commit -a
+  $ git-trac push 1234567/improved_feature.patch
+        EOF
+
+        TOPICS["arguments"] = ["Definitions for <ticket> and <attachment>"] << <<-EOF
+A <ticket> is specified by number, which may be optionally prefixed by a slash
+terminated string.
+    123456
+    trac/123456
+    http://dev.rubyonrails.org/ticket/123456
+
+An <attachment> is a <ticket> followed by a slash and a filename.  Anything
+in this filename after a slash or a question mark is ignored.
+    123456/foo.patch
+    trac/123456/foo.patch
+    http://dev.rubyonrails.org/attachment/ticket/123456/foo.patch
+    http://dev.rubyonrails.org/attachment/ticket/123456/foo.patch?format=raw
+
+If a ticket is given to a command expecting a multiple attachments, all the
+ticket's attachments are used.  If the command accepts just one attachment,
+just the ticket's last attachment is used.
+        EOF
+
+      end
+
+    end
+  end
+end

data/lib/git/trac/runner/push.rb

@@ -0,0 +1,79 @@
+module Git
+  module Trac
+    class Runner
+
+      class Push < Base #:nodoc:
+
+        def self.summary
+          "Upload the current diff against upstream to a ticket"
+        end
+
+        def banner_arguments
+          "[options] <ticket>[/<filename>]"
+        end
+
+        def description
+          <<-EOF
+Do a `git diff` and upload the result as an attachment to a ticket.  The
+potential patch will be shown in a pager and you will be given the opportunity
+to cancel.  If no filename is given, the name of the current branch plus
+".patch" is used.
+
+This command was formerly known as upload-patch.
+          EOF
+        end
+
+        def add_options(opts)
+          opts.on("--against BRANCH", "git diff BRANCH...HEAD") do |b|
+            options[:upstream] = b
+          end
+          opts.on("--description TEXT", "use TEXT as description") do |text|
+            options[:description] = text
+          end
+          opts.on("--[no-]force", "do not prompt before uploading") do |force|
+            options[:force] = force
+          end
+          add_local_option(opts)
+        end
+
+        def run
+          if @argv.size > 1
+            too_many_arguments
+          elsif @argv.empty?
+            number = repository.guess_current_ticket_number or
+            missing_argument "ticket"
+          else
+            number, options[:filename] = parse_attachment(@argv.shift)
+          end
+          fetch_unless_local
+          ticket = repository.ticket(number)
+          options[:upstream] ||= repository.guess_upstream || "refs/remotes/trunk"
+          options[:upstream] += "...HEAD" unless options[:upstream].include?(".")
+          if $stdin.tty? && !options[:force]
+            block = lambda do
+              repository.in_work_tree do
+                system("git","diff", options[:upstream])
+              end
+              description = "##{number} (#{ticket.csv["summary"]}"
+              cols = ENV["COLUMNS"].to_i
+              cols = 80 if cols.zero?
+              description.sub!(/^(.{#{cols-22}}).{4,}/,"\\1...")
+              print "#{description}) Proceed? [yN] "
+              $stdin.gets[0,1] == "y"
+            end
+          else
+            block = lambda { true }
+          end
+          if uri = ticket.upload_patch(options,&block)
+            puts uri
+          else
+            exit 1
+          end
+        end
+      end
+
+      UploadPatch = Push
+
+    end
+  end
+end