Changeset 296 in tailor

Timestamp:

05/10/05 11:47:07 (8 years ago)

Author:

Markus Schiltknecht <markus@…>

Hash name:

20050510094707-ff256-0a3d206aa9a7826918def462dff861a1b3bedd6b

Message:

Revised monotone support, merging with Riccardo patch
My --monotone_db and --monotone_branch options disappeared. The monotone
setup command now has to be called by the user. What I don't like about
this is: the user either

a) has to start tailor.py -b -t monotone ... first, get an error

message, invoke monotone setup in the correct directory and then
start tailor.py again. Or

b) he creates the directories which tailor creates himself and prepares

monotone setup there, then launches tailor.py.

With a) you have to cvs update && cvs rlog twice (in case of a CVS
source) which takes a lot of time and networking bandwith. It's obvious
that this isn't a nice way to go. b) requires a lot of knowledge from
the user. This could be documented, but options for tailor would be
nicer, IMHO.

Then there was the problem of monotone beeing called outside of it's
working copy for the very first commit during bootstrap. Riccardo has
solved that by not touching the MT/log but adding a --message options to
monotone. That's nice, too. I've come up with another solution: instead
of monotone commit $SUBDIR we can change to $SUBDIR and issue a plain
monotone commit there. So if MonotoneCommit? misses the MT directory it
now checks if only one entry (the subdir) was given. In that case it
changes the working directory to that subdir and commits there. That
solution now works with monotone-0.19 and seems better to me (we never
call monotone outside its working copy).

File:

• vcpx/monotone.py (modified) (4 diffs)

vcpx/monotone.py

@@ -18 +18 @@
 
 class MonotoneCommit(SystemCommand):
-    COMMAND = "MONOTONE_AUTHOR=\"%(key)s\" monotone commit --date=\"%(date)s\" %(entries)s"
+    COMMAND = "monotone commit --author=\"%(key)s\" --date=\"%(date)s\""
 
     def __call__(self, output=None, dry_run=False, **kwargs):
+
+        from os.path import exists, join
+
+        if not exists(join(self.working_dir, 'MT')):
+            # If MonotoneCommit is called outside the working copy
+            # (i.e. there is no MT directory) we test if we are given
+            # only the subdir as entry to commit. In that case, switch
+            # to root/subdir as working directory and issue a commit
+            # without any entries.
+            
+            entries = kwargs['entries']
+            entries = entries.replace(' ', '')
+            entries = entries.strip('\"')
+            if (exists(join(self.working_dir, entries))):
+                self.working_dir = join(self.working_dir, entries)
+                kwargs['entries'] = ""
+            else:
+                raise TargetInitializationFailure("not a valid monotone working copy (MT directory is missing in %s)" % self.working_dir)
+
         log = open(self.working_dir + "/MT/log", "w");
 
@@ -40 +59 @@
 
 
-class MonotoneWorkingDir(UpdatableSourceWorkingDir, SyncronizableTargetWorkingDir):
+class MonotoneWorkingDir(SyncronizableTargetWorkingDir):
 
     ## SyncronizableTargetWorkingDir
@@ -63 +82 @@
         else:
             entries = '.'
-            
-        c(key=author, logmessage=changelog, date=date, entries=entries)
 
+        # monotone doesn't like empty changelogs ...
+        if changelog == None or len(changelog)<1:
+            if len(remark)>0:
+                changelog = remark
+            else:
+                changelog = "**** empty log message ****"
+        changelog = changelog.replace('"', '\\"')
+        
+        # monotone date must be expressed as ISO8601 
+        outstr = c(output=True, key=author, logmessage=changelog,
+                   date=date.isoformat(), entries=entries)
+
+        # monotone complaints if there are no changes from the last commit.
+        # we ignore those errors ...
         if c.exit_status:
-            raise TargetInitializationFailure(
-                "'monotone commit returned %s" % c.exit_status)
+           if outstr.getvalue().find("monotone: misuse: no changes to commit") == -1:
+               outstr.close()
+               raise TargetInitializationFailure(
+                  "'monotone commit returned %s" % c.exit_status)
+        outstr.close()      
         
     def _removePathnames(self, root, names):
@@ -88 +122 @@
     def _initializeWorkingDir(self, root, repository, module, subdir):
         """
-        Execute `monotone setup`.
+        Setup the monotone working copy
+        
+        The user must setup a monotone working directory himself. Then
+        we simply use 'monotone commit', without having to specify a database
+        file or branch. Monotone looks up the database and branch in it's MT
+        directory.
         """
 
-        from os.path import join
+        from os.path import exists, join
         
-        c = SystemCommand(working_dir=root, command="monotone setup .")
-        c(output=True)
+        if not exists(join(root, subdir, 'MT')):
+            raise TargetInitializationFailure("Please setup %s as a monotone working directory." % root)
 
-        if c.exit_status:
-            raise TargetInitializationFailure(
-                "'monotone setup' returned status %s" % c.exit_status)
-
-        c = SystemCommand(working_dir=root,
+        c = SystemCommand(working_dir=join(root, subdir),
                           command="monotone add %(names)s")
-        c(names=shrepr(subdir))
+        c(names='.')