Changeset 777 in tailor


Ignore:
Timestamp:
09/07/05 14:50:48 (8 years ago)
Author:
lele@…
Hash name:
20050907125048-7a6fb-fc048cd801e38c478f7abdbb84305d06201fbe2f
Message:

Move the external command name detail into the Repository class

Location:
vcpx
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • vcpx/cvsps.py

    r745 r777  
    159159 
    160160        changesets = [] 
    161         cmd = [self.repository.CVSPS_CMD, "--cvs-direct", "-u", "-b", branch, 
    162                "--root", self.repository.repository] 
     161        cmd = self.repository.command("--cvs-direct", "-u", "-b", branch, 
     162                                      "--root", self.repository.repository, 
     163                                      cvsps=True) 
    163164        cvsps = ExternalCommand(command=cmd) 
    164165        log = cvsps.execute(self.repository.module, stdout=PIPE, TZ='UTC')[0] 
    … …  
    223224                rmtree(join(self.basedir, e.name)) 
    224225            else: 
    225                 cmd = [self.repository.CVS_CMD, "-q", "update", "-d", "-r", e.new_revision] 
     226                cmd = self.repository.command("-q", "update", "-d", 
     227                                              "-r", e.new_revision) 
    226228                cvsup = ExternalCommand(cwd=self.basedir, command=cmd) 
    227229                retry = 0 
    … …  
    293295 
    294296        if not exists(join(self.basedir, 'CVS')): 
    295             cmd = [self.repository.CVS_CMD, "-q", "-d", 
    296                    self.repository.repository, "checkout", 
    297                    "-d", self.repository.subdir] 
     297            cmd = self.repository.command("-q", 
     298                                          "-d", self.repository.repository, 
     299                                          "checkout", 
     300                                          "-d", self.repository.subdir) 
    298301            if revision: 
    299302                cmd.extend(["-r", revision]) 
    … …  
    438441        """ 
    439442 
    440         cmd = [self.repository.CVS_CMD, "-q", "add"] 
     443        cmd = self.repository.command("-q", "add") 
    441444        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    442445 
    … …  
    512515        log.close() 
    513516 
    514         cmd = [self.repository.CVS_CMD, "-q", "ci", "-F", rontf.name] 
     517        cmd = self.repository.command("-q", "ci", "-F", rontf.name) 
    515518        if not entries: 
    516519            entries = ['.'] 
    … …  
    528531        """ 
    529532 
    530         cmd = [self.repository.CVS_CMD, "-q", "remove"] 
     533        cmd = self.repository.command("-q", "remove") 
    531534        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    532535 

  • vcpx/darcs.py

    r776 r777  
    142142        from changes import Changeset 
    143143 
    144         cmd = [self.repository.DARCS_CMD, "pull", "--dry-run"] 
     144        cmd = self.repository.command("pull", "--dry-run") 
    145145        pull = ExternalCommand(cwd=self.basedir, command=cmd) 
    146146        output = pull.execute(self.repository.repository, 
    … …  
    225225                needspatchesopt = True 
    226226 
    227         cmd = [self.repository.DARCS_CMD, "pull", "--all", "--quiet", 
    228                selector, revtag] 
     227        cmd = self.repository.command("pull", "--all", "--quiet", 
     228                                      selector, revtag) 
    229229 
    230230        if needspatchesopt: 
    … …  
    249249            line = output.readline() 
    250250 
    251         cmd = [self.repository.DARCS_CMD, "changes", selector, revtag, 
    252                "--xml-output", "--summ"] 
     251        cmd = self.repository.command("changes", selector, revtag, 
     252                                      "--xml-output", "--summ") 
    253253        changes = ExternalCommand(cwd=self.basedir, command=cmd) 
    254254        last = changesets_from_darcschanges(changes.execute(stdout=PIPE)[0]) 
    … …  
    269269        self.log_info("Reverting changes to '%s', to solve the conflict" % 
    270270                      ' '.join(conflict)) 
    271         cmd = [self.repository.DARCS_CMD, "revert", "--all"] 
     271        cmd = self.repository.command("revert", "--all") 
    272272        revert = ExternalCommand(cwd=self.basedir, command=cmd) 
    273273        revert.execute(conflict) 
    … …  
    285285        if revision == 'INITIAL': 
    286286            initial = True 
    287             cmd = [self.repository.DARCS_CMD, "changes", "--xml-output", 
    288                    "--repo", self.repository.repository] 
     287            cmd = self.repository.command("changes", "--xml-output", 
     288                                          "--repo", self.repository.repository) 
    289289            changes = ExternalCommand(command=cmd) 
    290290            output = changes.execute(stdout=PIPE, stderr=STDOUT)[0] 
    … …  
    310310                    mkdir(self.basedir) 
    311311 
    312                 init = ExternalCommand(cwd=self.basedir, 
    313                                        command=[self.repository.DARCS_CMD, 
    314                                                 "initialize"]) 
     312                cmd = self.repository.command("initialize") 
     313                init = ExternalCommand(cwd=self.basedir, command=cmd) 
    315314                init.execute() 
    316315 
    … …  
    320319                                                   init.exit_status)) 
    321320 
    322                 cmd = [self.repository.DARCS_CMD, "pull", "--all", "--quiet"] 
     321                cmd = self.repository.command("pull", "--all", "--quiet") 
    323322                if revision and revision<>'HEAD': 
    324323                    cmd.extend([initial and "--match" or "--tag", revision]) 
    … …  
    333332        else: 
    334333            # Use much faster 'darcs get' 
    335             cmd = [self.repository.DARCS_CMD, "get", "--partial", "--quiet"] 
     334            cmd = self.repository.command("get", "--partial", "--quiet") 
    336335            if revision and revision<>'HEAD': 
    337336                cmd.extend([initial and "--to-match" or "--tag", revision]) 
    … …  
    345344                    (str(dget), dget.exit_status, output.read())) 
    346345 
    347         cmd = [self.repository.DARCS_CMD, "changes", "--last", "1", 
    348                "--xml-output"] 
     346        cmd = self.repository.command("changes", "--last", "1", 
     347                                      "--xml-output") 
    349348        changes = ExternalCommand(cwd=self.basedir, command=cmd) 
    350349        output = changes.execute(stdout=PIPE, stderr=STDOUT)[0] 
    … …  
    367366        """ 
    368367 
    369         cmd = [self.repository.DARCS_CMD, "add", "--case-ok", 
    370                "--not-recursive", "--quiet"] 
     368        cmd = self.repository.command("add", "--case-ok", "--not-recursive", 
     369                                      "--quiet") 
    371370        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    372371 
    … …  
    376375        """ 
    377376 
    378         cmd = [self.repository.DARCS_CMD, "add", "--case-ok", "--recursive", 
    379                "--quiet"] 
     377        cmd = self.repository.command("add", "--case-ok", "--recursive", 
     378                                      "--quiet") 
    380379        ExternalCommand(cwd=self.basedir, command=cmd).execute(subdir) 
    381380 
    … …  
    398397            logmessage.append('Unnamed patch') 
    399398 
    400         cmd = [self.repository.DARCS_CMD, "record", "--all", "--pipe"] 
     399        cmd = self.repository.command("record", "--all", "--pipe") 
    401400        if not entries: 
    402401            entries = ['.'] 
    … …  
    422421 
    423422        c = ExternalCommand(cwd=self.basedir, 
    424                             command=[self.repository.DARCS_CMD, "remove"]) 
     423                            command=self.repository.command("remove")) 
    425424        c.execute([n for n in names if exists(join(self.basedir, n))]) 
    426425 
    … …  
    447446 
    448447        try: 
    449             cmd = [self.repository.DARCS_CMD, "mv"] 
     448            cmd = self.repository.command("mv") 
    450449            ExternalCommand(cwd=self.basedir, command=cmd).execute(oldname, 
    451450                                                                   newname) 
    … …  
    465464 
    466465        if not exists(join(self.basedir, self.repository.METADIR)): 
    467             init = ExternalCommand(cwd=self.basedir, 
    468                                    command=[self.repository.DARCS_CMD, 
    469                                             "initialize"]) 
     466            cmd = self.repository.command("initialize") 
     467            init = ExternalCommand(cwd=self.basedir, command=cmd) 
    470468            init.execute() 
    471469 

  • vcpx/svn.py

    r738 r777  
    179179            sincerev = 0 
    180180 
    181         cmd = [self.repository.SVN_CMD, "log", "--verbose", "--xml", 
    182                "--revision", "%d:HEAD" % (sincerev+1)] 
     181        cmd = self.repository.command("log", "--verbose", "--xml", 
     182                                      "--revision", "%d:HEAD" % (sincerev+1)) 
    183183        svnlog = ExternalCommand(cwd=self.basedir, command=cmd) 
    184184        log = svnlog.execute('.', stdout=PIPE, TZ='UTC')[0] 
    … …  
    194194        from time import sleep 
    195195 
    196         cmd = [self.repository.SVN_CMD, "update", 
    197                "--revision", changeset.revision, "."] 
     196        cmd = self.repository.command("update", 
     197                                      "--revision", changeset.revision, ".") 
    198198        svnup = ExternalCommand(cwd=self.basedir, command=cmd) 
    199199 
    … …  
    239239        if revision == 'INITIAL': 
    240240            initial = True 
    241             cmd = [self.repository.SVN_CMD, "log", "--verbose", "--xml", 
    242                    "--limit", "1", "--revision", "1:HEAD"] 
     241            cmd = self.repository.command("log", "--verbose", "--xml", 
     242                                          "--limit", "1", 
     243                                          "--revision", "1:HEAD") 
    243244            svnlog = ExternalCommand(command=cmd) 
    244245            output = svnlog.execute("%s%s" % (self.repository.repository, 
    … …  
    260261        if not exists(join(self.basedir, '.svn')): 
    261262            self.log_info("checking out a working copy") 
    262             cmd = [self.repository.SVN_CMD, "co", "--quiet", 
    263                    "--revision", revision] 
     263            cmd = self.repository.command("co", "--quiet", 
     264                                          "--revision", revision) 
    264265            svnco = ExternalCommand(command=cmd) 
    265266            svnco.execute("%s%s" % (self.repository.repository, 
    … …  
    272273 
    273274        if not initial: 
    274             cmd = [self.repository.SVN_CMD, "log", "--verbose", "--xml", 
    275                    "--revision", revision=='HEAD' and 'COMMITTED' or revision] 
     275            cmd = self.repository.command("log", "--verbose", "--xml", 
     276                                          "--revision", revision=='HEAD' and 'COMMITTED' or revision) 
    276277            svnlog = ExternalCommand(cwd=self.basedir, command=cmd) 
    277278            output = svnlog.execute(stdout=PIPE)[0] 
    … …  
    299300        """ 
    300301 
    301         cmd = [self.repository.SVN_CMD, "add", "--quiet", "--no-auto-props", 
    302                "--non-recursive"] 
     302        cmd = self.repository.command("add", "--quiet", "--no-auto-props", 
     303                                      "--non-recursive") 
    303304        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    304305 
    … …  
    344345        log.close() 
    345346 
    346         cmd = [self.repository.SVN_CMD, "commit", "--quiet", 
    347                "--file", rontf.name] 
     347        cmd = self.repository.command("commit", "--quiet", 
     348                                      "--file", rontf.name) 
    348349        commit = ExternalCommand(cwd=self.basedir, command=cmd) 
    349350 
    … …  
    358359 
    359360        if self.USE_PROPSET: 
    360             cmd = [self.repository.SVN_CMD, "propset", "%(propname)s", 
    361                    "--quiet", "--revprop", "-rHEAD"] 
     361            cmd = self.repository.command("propset", "%(propname)s", 
     362                                          "--quiet", "--revprop", "-rHEAD") 
    362363            propset = ExternalCommand(cwd=self.basedir, command=cmd) 
    363364 
    … …  
    365366            propset.execute(author, propname='svn:author') 
    366367 
    367         cmd = [self.repository.SVN_CMD, "update", "--quiet"] 
     368        cmd = self.repository.command("update", "--quiet") 
    368369        ExternalCommand(cwd=self.basedir, command=cmd).execute() 
    369370 
    … …  
    373374        """ 
    374375 
    375         cmd = [self.repository.SVN_CMD, "remove", "--quiet", "--force"] 
     376        cmd = self.repository.command("remove", "--quiet", "--force") 
    376377        remove = ExternalCommand(cwd=self.basedir, command=cmd) 
    377378        remove.execute(names) 
    … …  
    382383        """ 
    383384 
    384         cmd = [self.repository.SVN_CMD, "mv", "--quiet"] 
     385        cmd = self.repository.command("mv", "--quiet") 
    385386        move = ExternalCommand(cwd=self.basedir, command=cmd) 
    386387        move.execute(oldname, newname) 
    … …  
    402403        assert target_repository.startswith('file:///') 
    403404 
    404         cmd = [self.repository.SVNADMIN_CMD, "create", "--fs-type", "fsfs"] 
     405        cmd = self.repository.command("create", "--fs-type", "fsfs", 
     406                                      svnadmin=True) 
    405407        svnadmin = ExternalCommand(command=cmd) 
    406408        svnadmin.execute(target_repository[7:]) 
    … …  
    412414 
    413415        if target_module and target_module <> '/': 
    414             cmd = [self.repository.SVN_CMD, "mkdir", "-m", 
    415                    "This directory will host the upstream sources"] 
     416            cmd = self.repository.command("mkdir", "-m", 
     417                                          "This directory will host the " 
     418                                          "upstream sources") 
    416419            svnmkdir = ExternalCommand(command=cmd) 
    417420            svnmkdir.execute(target_repository + target_module) 
    … …  
    431434 
    432435        # Verify the existence of repository by listing its root 
    433         cmd = [self.repository.SVN_CMD, "ls"] 
     436        cmd = self.repository.command("ls") 
    434437        svnls = ExternalCommand(command=cmd) 
    435438        svnls.execute(self.repository.repository) 
    … …  
    456459            return 
    457460 
    458         cmd = [self.repository.SVN_CMD, "co", "--quiet"] 
     461        cmd = self.repository.command("co", "--quiet") 
    459462        svnco = ExternalCommand(command=cmd) 
    460463        svnco.execute("%s%s" % (self.repository.repository, 

  • vcpx/cvs.py

    r775 r777  
    307307                branch=tag[1:-1] 
    308308 
    309         cmd = [self.repository.CVS_CMD, "-f", "-d", "%(repository)s", "rlog", 
    310                "-N"] 
     309        cmd = self.repository.command("-f", "-d", "%(repository)s", "rlog", 
     310                                      "-N") 
    311311 
    312312        if not sincerev or sincerev in ("INITIAL", "HEAD"): 

  • vcpx/monotone.py

    r708 r777  
    132132        self.changelog="" 
    133133 
    134         cmd = [self.repository.MONOTONE_CMD, "log", "--db", self.repository.repository, "--last", "1", "--revision", revision] 
     134        cmd = self.repository.command("log", "--db", self.repository.repository, 
     135                                      "--last", "1", "--revision", revision) 
    135136        mtl = ExternalCommand(cwd=self.working_dir, command=cmd) 
    136137        outstr = mtl.execute(stdout=PIPE) 
    … …  
    299300     
    300301        # the order of revisions is very important. Monotone gives a diff from the first to the second 
    301         cmd = [self.repository.MONOTONE_CMD, "diff", "--db", self.repository.repository, "--revision", chset.lin_ancestor, "--revision", chset.revision] 
     302        cmd = self.repository.command("diff", 
     303                                      "--db", self.repository.repository, 
     304                                      "--revision", chset.lin_ancestor, 
     305                                      "--revision", chset.revision) 
    302306 
    303307        mtl = ExternalCommand(cwd=self.working_dir, command=cmd) 
    … …  
    449453        if revision == 'HEAD' or revision=='INITIAL': 
    450454            # in both cases we need the head(s) of the requested branch 
    451             cmd = [self.repository.MONOTONE_CMD, "automate","heads", "--db", repository, module] 
     455            cmd = self.repository.command("automate","heads", 
     456                                          "--db", repository, module) 
    452457            mtl = ExternalCommand(cwd=working_dir, command=cmd) 
    453458            outstr = mtl.execute(stdout=PIPE) 
    … …  
    466471                if len(revision)>1: 
    467472                    stderr.write("Branch '%s' has multiple heads. There is no guarantee to reconstruct the full history." % module) 
    468                 cmd = [ [self.repository.MONOTONE_CMD, "automate","ancestors", 
    469                             "--db",repository], 
    470                         [self.repository.MONOTONE_CMD, "automate","toposort", 
    471                             "--db",repository, "-@-"] 
     473                cmd = [ self.repository.command("automate","ancestors", 
     474                                                "--db",repository), 
     475                        self.repository.command("automate","toposort", 
     476                                                "--db",repository, "-@-") 
    472477                        ] 
    473478                cmd[0].extend(revision) 
    … …  
    486491        # here we want ancestry order, so descendents output is feed back to  
    487492        # mtn for a toposort ... 
    488         cmd = [ [self.repository.MONOTONE_CMD, "automate","descendents", 
    489                     "--db",self.repository.repository, sincerev], 
    490                 [self.repository.MONOTONE_CMD, "automate","toposort", 
    491                     "--db",self.repository.repository, "-@-"] 
     493        cmd = [ self.repository.command("automate","descendents", 
     494                                        "--db", self.repository.repository, 
     495                                        sincerev), 
     496                self.repository.command("automate","toposort", 
     497                                        "--db", self.repository.repository, 
     498                                        "-@-") 
    492499                ] 
    493500        cld = ExternalCommandChain(cwd=self.repository.rootdir, command=cmd) 
    … …  
    508515 
    509516    def _applyChangeset(self, changeset): 
    510         cmd = [self.repository.MONOTONE_CMD, "update", "--revision", changeset.revision] 
     517        cmd = self.repository.command("update", "--revision", changeset.revision) 
    511518        mtl = ExternalCommand(cwd=self.basedir, command=cmd) 
    512519        mtl.execute() 
    … …  
    525532        if not exists(join(self.basedir, 'MT')): 
    526533            self.log_info("checking out a working copy") 
    527             cmd = [self.repository.MONOTONE_CMD, "co", "--db", self.repository.repository, "--revision", effrev,  
    528                     "--branch", self.repository.module, self.repository.subdir] 
     534            cmd = self.repository.command("co", 
     535                                          "--db", self.repository.repository, 
     536                                          "--revision", effrev,  
     537                                          "--branch", self.repository.module, 
     538                                          self.repository.subdir) 
    529539            mtl = ExternalCommand(cwd=self.repository.rootdir, command=cmd) 
    530540            mtl.execute() 
    … …  
    561571        if len(fnames): 
    562572            # ok, we still have something to add 
    563             cmd = [self.repository.MONOTONE_CMD, "add"] 
     573            cmd = self.repository.command("add") 
    564574            add = ExternalCommand(cwd=self.basedir, command=cmd) 
    565575            add.execute(fnames) 
    … …  
    572582        Add a whole subtree 
    573583        """ 
    574         cmd = [self.repository.MONOTONE_CMD, "add"] 
     584        cmd = self.repository.command("add") 
    575585        add = ExternalCommand(cwd=self.basedir, command=cmd) 
    576586        add.execute(subdir) 
    … …  
    598608        log.close() 
    599609 
    600         cmd = [self.repository.MONOTONE_CMD, "commit", "--author", author, 
    601                "--date", date.isoformat(), 
    602                "--message-file", rontf.name] 
     610        cmd = self.repository.command("commit", "--author", author, 
     611                                      "--date", date.isoformat(), 
     612                                      "--message-file", rontf.name) 
    603613        commit = ExternalCommand(cwd=self.basedir, command=cmd) 
    604614 
    … …  
    627637        # so we must remove every item separately and intercept monotone directory errore messages. 
    628638        # We can't just filter the directories, because the wc doesn't contain them anymore ... 
    629         cmd = [self.repository.MONOTONE_CMD, "drop"] 
     639        cmd = self.repository.command("drop") 
    630640        drop = ExternalCommand(cwd=self.basedir, command=cmd) 
    631641        for fn in names: 
    … …  
    649659            self.log_info("preparing to rename %s->%s" % (oldname, newname)) 
    650660         
    651         cmd = [self.repository.MONOTONE_CMD, "rename"] 
     661        cmd = self.repository.command("rename") 
    652662        rename = ExternalCommand(cwd=self.basedir, command=cmd) 
    653663        rename.execute(oldname, newname) 
    … …  
    663673        """ 
    664674 
    665         cmd = [self.repository.MONOTONE_CMD, "db", "init", "--db", 
    666                target_repository.repository] 
     675        cmd = self.repository.command("db", "init", "--db", 
     676                                      target_repository.repository) 
    667677        init = ExternalCommand(command=cmd) 
    668678        init.execute() 
    … …  
    676686            # a key file is available, read into the database 
    677687            keyfile = file(target_repository.keyfile) 
    678             cmd = [self.repository.MONOTONE_CMD, "read", "--db", 
    679                    target_repository.repository] 
     688            cmd = self.repository.command("read", "--db", 
     689                                          target_repository.repository) 
    680690            regkey = ExternalCommand(command=cmd) 
    681691            regkey.execute(input=keyfile) 
    … …  
    688698                                                  "A keyfile or keyid must be provided." % 
    689699                                                  target_repository) 
    690             cmd = [self.repository.MONOTONE_CMD, "genkey", "--db", 
    691                    target_repository.repository] 
     700            cmd = self.repository.command("genkey", "--db", 
     701                                          target_repository.repository) 
    692702            regkey = ExternalCommand(command=cmd) 
    693703            if target_repository.passphrase: 
    … …  
    724734            return 
    725735 
    726         cmd = [self.repository.MONOTONE_CMD, "setup", 
    727                "--db", self.repository.repository, "--branch", self.repository.module] 
     736        cmd = self.repository.command("setup", 
     737                                      "--db", self.repository.repository, 
     738                                      "--branch", self.repository.module) 
    728739         
    729740        if not self.repository.module: 

  • vcpx/cdv.py

    r752 r777  
    2828 
    2929        names = [e.name for e in changeset.modifiedEntries()] 
    30         cmd = [self.repository.CDV_CMD, "edit"] 
     30        cmd = self.repository.command("edit") 
    3131        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    3232 
    … …  
    3636        """ 
    3737 
    38         cmd = [self.repository.CDV_CMD, "add"] 
     38        cmd = self.repository.command("add") 
    3939        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    4040 
    … …  
    5454            logmessage.append(changelog.replace('%', '%%').encode(encoding)) 
    5555 
    56         cmd = [self.repository.CDV_CMD, "-u", author.encode(encoding), "commit", 
    57                "-m", '\n'.join(logmessage), 
    58                "-D", date.strftime('%Y/%m/%d %H:%M:%S UTC')] 
     56        cmd = self.repository.command("-u", author.encode(encoding), "commit", 
     57                                      "-m", '\n'.join(logmessage), 
     58                                      "-D", date.strftime('%Y/%m/%d %H:%M:%S UTC')) 
    5959 
    6060        if not entries: 
    … …  
    7373        """ 
    7474 
    75         cmd = [self.repository.CDV_CMD, "remove"] 
     75        cmd = self.repository.command("remove") 
    7676        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    7777 
    … …  
    8181        """ 
    8282 
    83         cmd = [self.repository.CDV_CMD, "rename"] 
     83        cmd = self.repository.command("rename") 
    8484        ExternalCommand(cwd=self.basedir, command=cmd).execute(oldname, newname) 
    8585 
    … …  
    9595        if not exists(join(self.basedir, self.repository.METADIR)): 
    9696            init = ExternalCommand(cwd=self.basedir, 
    97                                    command=[self.repository.CDV_CMD, "init"]) 
     97                                   command=self.repository.command("init")) 
    9898            init.execute() 
    9999 
    … …  
    110110        from os.path import join 
    111111 
    112         cmd = [self.repository.CDV_CMD, "set", "user"] 
     112        cmd = self.repository.command("set", "user") 
    113113        user = getenv('CDV_USER') or getenv('LOGNAME') 
    114114        ExternalCommand(cwd=self.basedir, command=cmd).execute(user) 

  • vcpx/bzr.py

    r752 r777  
    2525        """ 
    2626 
    27         cmd = [self.repository.BZR_CMD, "add"] 
     27        cmd = self.repository.command("add") 
    2828        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    2929 
    … …  
    5151        log.close() 
    5252 
    53         cmd = [self.repository.BZR_CMD, "commit", "--unchanged", 
    54                "--file", rontf.name] 
     53        cmd = self.repository.command("commit", "--unchanged", 
     54                                      "--file", rontf.name) 
    5555        if not entries: 
    5656            entries = ['.'] 
    … …  
    6868        """ 
    6969 
    70         cmd = [self.repository.BZR_CMD, "remove"] 
     70        cmd = self.repository.command("remove") 
    7171        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    7272 
    … …  
    7676        """ 
    7777 
    78         cmd = [self.repository.BZR_CMD, "rename"] 
     78        cmd = self.repository.command("rename") 
    7979        ExternalCommand(cwd=self.basedir, command=cmd).execute(oldname, newname) 
    8080 
    … …  
    8989 
    9090        if not exists(join(self.basedir, self.repository.METADIR)): 
    91             cmd = [self.repository.BZR_CMD, "init"] 
     91            cmd = self.repository.command("init") 
    9292            init = ExternalCommand(cwd=self.basedir, command=cmd) 
    9393            init.execute() 

  • vcpx/hg.py

    r752 r777  
    3232        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    3333        if notdirs: 
    34             cmd = [self.repository.HG_CMD, "add"] 
     34            cmd = self.repository.command("add") 
    3535            ExternalCommand(cwd=self.basedir, command=cmd).execute(notdirs) 
    3636 
    … …  
    5151            logmessage.append(changelog.encode(encoding)) 
    5252 
    53         cmd = [self.repository.HG_CMD, "commit", "-u", author, 
    54                "-l", "%(logfile)s", 
    55                "-d", "%(time)d 0"] 
     53        cmd = self.repository.command("commit", "-u", author, 
     54                                      "-l", "%(logfile)s", 
     55                                      "-d", "%(time)d 0") 
    5656        c = ExternalCommand(cwd=self.basedir, command=cmd) 
    5757 
    … …  
    7979        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    8080        if notdirs: 
    81             cmd = [self.repository.HG_CMD, "remove"] 
     81            cmd = self.repository.command("remove") 
    8282            ExternalCommand(cwd=self.basedir, command=cmd).execute(notdirs) 
    8383 
    … …  
    9191        from dualwd import IGNORED_METADIRS 
    9292 
    93         cmd = [self.repository.HG_CMD, "copy"] 
     93        cmd = self.repository.command("copy") 
    9494        copy = ExternalCommand(cwd=self.basedir, command=cmd) 
    9595        if isdir(join(self.basedir, newname)): 
    … …  
    120120        if not exists(join(self.basedir, self.repository.METADIR)): 
    121121            init = ExternalCommand(cwd=self.basedir, 
    122                                    command=[self.repository.HG_CMD, "init"]) 
     122                                   command=self.repository.command("init")) 
    123123            init.execute() 
    124124 
    … …  
    162162 
    163163        ExternalCommand(cwd=self.basedir, 
    164                         command=[self.repository.HG_CMD, "addremove"]).execute() 
     164                        command=self.repository.command("addremove")).execute() 

  • vcpx/repository.py

    r755 r777  
    2323    METADIR = None 
    2424    EXTRA_METADIRS = [] 
     25    EXECUTABLE = None 
    2526 
    2627    def __new__(klass, name, project, which): 
    … …  
    9091        """ 
    9192 
     93        if self.EXECUTABLE: 
     94            from os import getenv 
     95            from os.path import isabs, exists, join 
     96            from vcpx.config import ConfigurationError 
     97 
     98            if isabs(self.EXECUTABLE): 
     99                ok = exists(self.EXECUTABLE) 
     100            else: 
     101                ok = False 
     102                for path in getenv('PATH').split(':'): 
     103                    if exists(join(path, self.EXECUTABLE)): 
     104                        ok = True 
     105                        break 
     106            if not ok: 
     107                raise ConfigurationError("The command %r used " 
     108                                         "by %r does not exist!" % 
     109                                         (self.EXECUTABLE, self.name)) 
     110 
    92111    def log_info(self, what): 
    93112        """ 
    … …  
    123142        return workingdir(self) 
    124143 
     144    def command(self, *args, **kwargs): 
     145        """ 
     146        Return the base external command, a sequence suitable to be used 
     147        to init an ExternalCommand instance. 
     148 
     149        This return None if the backend uses a different way to execute 
     150        its actions. 
     151        """ 
     152 
     153        executable = kwargs.get('executable', self.EXECUTABLE) 
     154        if executable: 
     155            cmd = [executable] 
     156            cmd.extend(args) 
     157            return cmd 
    125158 
    126159class ArxRepository(Repository): 
    127160    METADIR = '_arx' 
    128     ARX_CMD = "arx" 
    129  
    130     def _load(self, config): 
    131         Repository._load(self, config) 
    132         self.ARX_CMD = config.get(self.name, 'arx-command', self.ARX_CMD) 
     161 
     162    def _load(self, config): 
     163        Repository._load(self, config) 
     164        self.EXECUTABLE = config.get(self.name, 'arx-command', 'arx') 
    133165 
    134166 
    135167class BazRepository(Repository): 
    136168    METADIR = '{arch}' 
    137     BAZ_CMD = "baz" 
    138  
    139     def _load(self, config): 
    140         Repository._load(self, config) 
    141         self.BAZ_CMD = config.get(self.name, 'baz-command', self.BAZ_CMD) 
     169 
     170    def _load(self, config): 
     171        Repository._load(self, config) 
     172        self.EXECUTABLE = config.get(self.name, 'baz-command', 'baz') 
    142173 
    143174 
    144175class BzrRepository(Repository): 
    145176    METADIR = '.bzr' 
    146     BZR_CMD = 'bzr' 
    147  
    148     def _load(self, config): 
    149         Repository._load(self, config) 
    150         self.BZR_CMD = config.get(self.name, 'bzr-command', self.BZR_CMD) 
     177 
     178    def _load(self, config): 
     179        Repository._load(self, config) 
     180        self.EXECUTABLE = config.get(self.name, 'bzr-command', 'bzr') 
    151181 
    152182 
    … …  
    166196class CdvRepository(Repository): 
    167197    METADIR = '.cdv' 
    168     CDV_CMD = 'cdv' 
    169  
    170     def _load(self, config): 
    171         Repository._load(self, config) 
    172         self.CDV_CMD = config.get(self.name, 'cdv-command', self.CDV_CMD) 
     198 
     199    def _load(self, config): 
     200        Repository._load(self, config) 
     201        self.EXECUTABLE = config.get(self.name, 'cdv-command', 'cdv') 
    173202 
    174203 
    175204class CgRepository(Repository): 
    176205    METADIR = '.git' 
    177     CG_CMD = 'cg' 
    178  
    179     def _load(self, config): 
    180         Repository._load(self, config) 
    181         self.CG_CMD = config.get(self.name, 'cg-command', self.CG_CMD) 
     206 
     207    def _load(self, config): 
     208        Repository._load(self, config) 
     209        self.EXECUTABLE = config.get(self.name, 'cg-command', 'cg') 
    182210 
    183211 
    184212class CvsRepository(Repository): 
    185213    METADIR = 'CVS' 
    186     CVS_CMD = 'cvs' 
    187  
    188     def _load(self, config): 
    189         Repository._load(self, config) 
    190         self.CVS_CMD = config.get(self.name, 'cvs-command', self.CVS_CMD) 
     214 
     215    def _load(self, config): 
     216        Repository._load(self, config) 
     217        self.EXECUTABLE = config.get(self.name, 'cvs-command', 'cvs') 
    191218        self.tag_entries = config.get(self.name, 'tag-entries', 'True') 
    192219 
    … …  
    195222        from config import ConfigurationError 
    196223 
     224        Repository._validateConfiguration(self) 
     225 
    197226        if not self.module and self.repository: 
    198227            self.module = split(self.repository)[1] 
    … …  
    204233 
    205234class CvspsRepository(CvsRepository): 
    206     CVSPS_CMD = 'cvsps' 
     235    def command(self, *args, **kwargs): 
     236        if kwargs.get('cvsps', False): 
     237            kwargs['executable'] = self.__cvsps 
     238        return CvsRepository.command(self, *args, **kwargs) 
    207239 
    208240    def _load(self, config): 
    209241        CvsRepository._load(self, config) 
    210         self.CVSPS_CMD = config.get(self.name, 'cvsps-command', self.CVSPS_CMD) 
     242        self.__cvsps = config.get(self.name, 'cvsps-command', 'cvsps') 
    211243        self.tag_entries = config.get(self.name, 'tag-entries', 'True') 
    212244 
    … …  
    214246class DarcsRepository(Repository): 
    215247    METADIR = '_darcs' 
    216     DARCS_CMD = 'darcs' 
    217  
    218     def _load(self, config): 
    219         Repository._load(self, config) 
    220         self.DARCS_CMD = config.get(self.name, 'darcs-command', self.DARCS_CMD) 
     248 
     249    def _load(self, config): 
     250        Repository._load(self, config) 
     251        self.EXECUTABLE = config.get(self.name, 'darcs-command', 'darcs') 
    221252 
    222253 
    223254class HgRepository(Repository): 
    224255    METADIR = '.hg' 
    225     HG_CMD = "hg" 
    226  
    227     def _load(self, config): 
    228         Repository._load(self, config) 
    229         self.HG_CMD = config.get(self.name, 'hg-command', self.HG_CMD) 
     256 
     257    def _load(self, config): 
     258        Repository._load(self, config) 
     259        self.EXECUTABLE = config.get(self.name, 'hg-command', 'hg') 
    230260 
    231261 
    232262class MonotoneRepository(Repository): 
    233263    METADIR = 'MT' 
    234     MONOTONE_CMD = "monotone" 
    235  
    236     def _load(self, config): 
    237         Repository._load(self, config) 
    238         self.MONOTONE_CMD = config.get(self.name, 
    239                                        'monotone-command', self.MONOTONE_CMD) 
     264 
     265    def _load(self, config): 
     266        Repository._load(self, config) 
     267        self.EXECUTABLE = config.get(self.name, 'monotone-command', 'monotone') 
    240268        self.keyid = config.get(self.name, 'keyid') 
    241269        self.passphrase = config.get(self.name, 'passphrase') 
    … …  
    245273class SvnRepository(Repository): 
    246274    METADIR = '.svn' 
    247     SVN_CMD = "svn" 
    248     SVNADMIN_CMD = "svnadmin" 
    249  
    250     def _load(self, config): 
    251         Repository._load(self, config) 
    252         self.SVN_CMD = config.get(self.name, 'svn-command', self.SVN_CMD) 
    253         self.SVNADMIN_CMD = config.get(self.name, 
    254                                        'svnadmin-command', self.SVNADMIN_CMD) 
     275 
     276    def command(self, *args, **kwargs): 
     277        if kwargs.get('svnadmin', False): 
     278            kwargs['executable'] = self.__svnadmin 
     279        return Repository.command(self, *args, **kwargs) 
     280 
     281    def _load(self, config): 
     282        Repository._load(self, config) 
     283        self.EXECUTABLE = config.get(self.name, 'svn-command', 'svn') 
     284        self.__svnadmin = config.get(self.name, 'svnadmin-command', 'svnadmin') 
    255285        self.use_propset = config.get(self.name, 'use-propset', False) 
    256286 
    257287    def _validateConfiguration(self): 
    258288        from vcpx.config import ConfigurationError 
     289 
     290        Repository._validateConfiguration(self) 
    259291 
    260292        if not self.repository: 
    … …  
    281313 
    282314    def _validateConfiguration(self): 
     315        Repository._validateConfiguration(self) 
     316 
    283317        if self.module and self.module.startswith('/'): 
    284318            self.project.log_info("Removing starting '/' from module") 
    … …  
    289323class TlaRepository(Repository): 
    290324    METADIR = '{arch}' 
    291     TLA_CMD = "tla" 
    292  
    293     def _load(self, config): 
    294         Repository._load(self, config) 
    295         self.TLA_CMD = config.get(self.name, 'tla-command', self.TLA_CMD) 
     325 
     326    def _load(self, config): 
     327        Repository._load(self, config) 
     328        self.EXECUTABLE = config.get(self.name, 'tla-command', 'tla') 
    296329        self.IGNORE_IDS = config.get(self.name, 'ignore-ids', False) 
    297330        if self.IGNORE_IDS: 

  • vcpx/arx.py

    r671 r777  
    2626        """ 
    2727 
    28         cmd = [self.repository.ARX_CMD, "add"] 
     28        cmd = self.repository.command("add") 
    2929        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    3030 
    … …  
    4545            logmessage.append(changelog.replace('%', '%%').encode(encoding)) 
    4646 
    47         cmd = [self.repository.ARX_CMD, "commit", "-s", '\n'.join(logmessage), 
    48                "--author", author, 
    49                "--date", date.isoformat()] 
     47        cmd = self.repository.command("commit", "-s", '\n'.join(logmessage), 
     48                                      "--author", author, 
     49                                      "--date", date.isoformat()) 
    5050        c = ExternalCommand(cwd=self.basedir, command=cmd) 
    5151        c.execute() 
    … …  
    6060        """ 
    6161 
    62         cmd = [self.repository.ARX_CMD, "rm"] 
     62        cmd = self.repository.command("rm") 
    6363        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    6464 
    … …  
    6868        """ 
    6969 
    70         cmd = [self.repository.ARX_CMD, "copy"] 
     70        cmd = self.repository.command("copy") 
    7171        rename = ExternalCommand(cwd=self.basedir, command=cmd) 
    7272        rename.execute(oldname, newname) 

  • vcpx/tla.py

    r708 r777  
    7070                                   self.repository.module]) 
    7171        c = ExternalCommand(cwd=self.basedir, 
    72                             command=[self.repository.TLA_CMD, "missing", "-f"]) 
     72                            command=self.repository.command("missing", "-f")) 
    7373        out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    7474        if c.exit_status: 
    … …  
    125125        if not os.path.exists(root): 
    126126            os.makedirs(root) 
    127         c = ExternalCommand(cwd=root, 
    128                             command=[self.repository.TLA_CMD, "get", 
    129                                      "--no-pristine", fqrev, destdir]) 
     127        cmd = self.repository.command("get", "--no-pristine", fqrev, destdir) 
     128        c = ExternalCommand(cwd=root, command=cmd) 
    130129        out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    131130        if c.exit_status: 
    … …  
    136135    def __apply_changeset(self, changeset): 
    137136        c = ExternalCommand(cwd=self.basedir, 
    138                             command=[self.repository.TLA_CMD, "replay"]) 
     137                            command=self.repository.command("replay")) 
    139138        out, err = c.execute(changeset.revision, stdout=PIPE, stderr=PIPE) 
    140139        if not c.exit_status in [0, 1]: 
    … …  
    151150                path = path[2:] 
    152151        if path.find("\(") != -1: 
    153             c = ExternalCommand(command=[self.repository.TLA_CMD, "escape", 
    154                                          "--unescaped", path]) 
     152            cmd = self.repository.command("escape", "--unescaped", path) 
     153            c = ExternalCommand(command=cmd) 
    155154            out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    156155            if c.exit_status: 
    … …  
    165164                              self.repository.module]) 
    166165        if revision in ['HEAD', 'INITIAL']: 
    167             cmd = [self.repository.TLA_CMD, "revisions"] 
     166            cmd = self.repository.command("revisions") 
    168167            if revision == 'HEAD': 
    169168                cmd.append("-r") 
    … …  
    182181        logparser = Parser() 
    183182        c = ExternalCommand(cwd=self.basedir, 
    184                             command=[self.repository.TLA_CMD, 
    185                                      "cat-archive-log"]) 
     183                            command=self.repository.command("cat-archive-log")) 
    186184        for fqrev in fqrevlist: 
    187185            out, err = c.execute(fqrev, stdout=PIPE, stderr=PIPE) 
    … …  
    219217    def __hide_foreign_entries(self): 
    220218        c = ExternalCommand(cwd=self.basedir, 
    221                             command=[self.repository.TLA_CMD, 
    222                                      "tree-lint", "-tu"]) 
     219                            command=self.repository.command("tree-lint", "-tu")) 
    223220        out = c.execute(stdout=PIPE)[0] 
    224221        tempdir = None 

  • vcpx/cg.py

    r752 r777  
    3232        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    3333        if notdirs: 
    34             cmd = [self.repository.CG_CMD, "add"] 
     34            cmd = self.repository.command("add") 
    3535            ExternalCommand(cwd=self.basedir, command=cmd).execute(notdirs) 
    3636 
    … …  
    8383        # '-f' flag means we can get empty commits, which 
    8484        # shouldn't be a problem. 
    85         cmd = [self.repository.CG_CMD, "commit", "-f"] 
     85        cmd = self.repository.command("commit", "-f") 
    8686        c = ExternalCommand(cwd=self.basedir, command=cmd) 
    8787 
    … …  
    102102        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    103103        if notdirs: 
    104             cmd = [self.repository.CG_CMD, "rm"] 
     104            cmd = self.repository.command("rm") 
    105105            c=ExternalCommand(cwd=self.basedir, command=cmd) 
    106106            c.execute(notdirs) 
    … …  
    144144 
    145145        if not exists(join(self.basedir, self.repository.METADIR)): 
    146             init = ExternalCommand(cwd=self.basedir, 
    147                                    command=[self.repository.CG_CMD, 
    148                                             "init", "-I"]) 
     146            cmd = self.repository.command("init", "-I") 
     147            init = ExternalCommand(cwd=self.basedir, command=cmd) 
    149148            init.execute() 
    150149 

  • vcpx/baz.py

    r708 r777  
    7272                                   self.repository.module]) 
    7373        c = ExternalCommand(cwd=self.basedir, 
    74                             command=[self.repository.BAZ_CMD, "missing", "-f"]) 
     74                            command=self.repository.command("missing", "-f")) 
    7575        out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    7676        if c.exit_status: 
    … …  
    9191        try: 
    9292            c = ExternalCommand(cwd=self.basedir, 
    93                                 command=[self.repository.BAZ_CMD, "replay"]) 
     93                                command=self.repository.command("replay")) 
    9494            out, err = c.execute(changeset.revision, stdout=PIPE, stderr=PIPE) 
    9595            if not c.exit_status in [0, 1]: 
    … …  
    113113        tempdir = mkdtemp("", ",,tailor-", self.basedir) 
    114114        try: 
     115            cmd = self.repository.command("get", "--no-pristine", fqrev, "t") 
    115116            c = ExternalCommand(cwd=os.path.join(self.basedir, tempdir), 
    116                                 command=[self.repository.BAZ_CMD, "get", 
    117                                          "--no-pristine", fqrev, "t"]) 
     117                                command=cmd) 
    118118            out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    119119            if c.exit_status: 
    … …  
    144144                path = path[2:] 
    145145        if path.find("\(") != -1: 
    146             c = ExternalCommand(command=[self.repository.BAZ_CMD, "escape", 
    147                                          "--unescaped", path]) 
     146            cmd = self.repository.command("escape", "--unescaped", path) 
     147            c = ExternalCommand(command=cmd) 
    148148            out, err = c.execute(stdout=PIPE, stderr=PIPE) 
    149149            if c.exit_status: 
    … …  
    158158                              self.repository.module]) 
    159159        if revision in ['HEAD', 'INITIAL']: 
    160             cmd = [self.repository.BAZ_CMD, "revisions"] 
     160            cmd = self.repository.command("revisions") 
    161161            if revision == 'HEAD': 
    162162                cmd.append("-r") 
    … …  
    175175        logparser = Parser() 
    176176        c = ExternalCommand(cwd=self.basedir, 
    177                             command=[self.repository.BAZ_CMD, 
    178                                      "cat-archive-log"]) 
     177                            command=self.repository.command("cat-archive-log")) 
    179178        for fqrev in fqrevlist: 
    180179            out, err = c.execute(fqrev, stdout=PIPE, stderr=PIPE) 
    … …  
    212211    def __hide_foreign_entries(self): 
    213212        c = ExternalCommand(cwd=self.basedir, 
    214                             command=[self.repository.BAZ_CMD, 
    215                                      "lint", "-tu"]) 
     213                            command=self.repository.command("lint", "-tu")) 
    216214        out = c.execute(stdout=PIPE) 
    217215        tempdir = None 
Note: See TracChangeset for help on using the changeset viewer.