001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *   http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied.  See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 */
019package org.apache.maven.scm.provider;
020
021import java.io.File;
022import java.util.ArrayList;
023import java.util.Date;
024import java.util.List;
025
026import org.apache.maven.scm.CommandParameter;
027import org.apache.maven.scm.CommandParameters;
028import org.apache.maven.scm.NoSuchCommandScmException;
029import org.apache.maven.scm.ScmBranch;
030import org.apache.maven.scm.ScmBranchParameters;
031import org.apache.maven.scm.ScmException;
032import org.apache.maven.scm.ScmFileSet;
033import org.apache.maven.scm.ScmRevision;
034import org.apache.maven.scm.ScmTagParameters;
035import org.apache.maven.scm.ScmVersion;
036import org.apache.maven.scm.command.add.AddScmResult;
037import org.apache.maven.scm.command.blame.BlameScmRequest;
038import org.apache.maven.scm.command.blame.BlameScmResult;
039import org.apache.maven.scm.command.branch.BranchScmResult;
040import org.apache.maven.scm.command.changelog.ChangeLogScmRequest;
041import org.apache.maven.scm.command.changelog.ChangeLogScmResult;
042import org.apache.maven.scm.command.checkin.CheckInScmResult;
043import org.apache.maven.scm.command.checkout.CheckOutScmResult;
044import org.apache.maven.scm.command.diff.DiffScmResult;
045import org.apache.maven.scm.command.edit.EditScmResult;
046import org.apache.maven.scm.command.export.ExportScmResult;
047import org.apache.maven.scm.command.info.InfoScmResult;
048import org.apache.maven.scm.command.list.ListScmResult;
049import org.apache.maven.scm.command.login.LoginScmResult;
050import org.apache.maven.scm.command.mkdir.MkdirScmResult;
051import org.apache.maven.scm.command.remoteinfo.RemoteInfoScmResult;
052import org.apache.maven.scm.command.remove.RemoveScmResult;
053import org.apache.maven.scm.command.status.StatusScmResult;
054import org.apache.maven.scm.command.tag.TagScmResult;
055import org.apache.maven.scm.command.unedit.UnEditScmResult;
056import org.apache.maven.scm.command.untag.UntagScmResult;
057import org.apache.maven.scm.command.update.UpdateScmResult;
058import org.apache.maven.scm.repository.ScmRepository;
059import org.apache.maven.scm.repository.ScmRepositoryException;
060import org.apache.maven.scm.repository.UnknownRepositoryStructure;
061import org.codehaus.plexus.util.StringUtils;
062import org.slf4j.Logger;
063import org.slf4j.LoggerFactory;
064
065/**
066 * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>
067 * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
068 * @author Olivier Lamy
069 *
070 */
071public abstract class AbstractScmProvider implements ScmProvider {
072    protected final Logger logger = LoggerFactory.getLogger(getClass());
073
074    // ----------------------------------------------------------------------
075    //
076    // ----------------------------------------------------------------------
077
078    /**
079     * {@inheritDoc}
080     */
081    @Override
082    public String getScmSpecificFilename() {
083        return null;
084    }
085
086    /**
087     * {@inheritDoc}
088     */
089    @Override
090    public String sanitizeTagName(String tag) {
091        /* by default, we assume all tags are valid. */
092        return tag;
093    }
094
095    /**
096     * {@inheritDoc}
097     */
098    @Override
099    public boolean validateTagName(String tag) {
100        /* by default, we assume all tags are valid. */
101        return true;
102    }
103
104    /**
105     * {@inheritDoc}
106     */
107    @Override
108    public List<String> validateScmUrl(String scmSpecificUrl, char delimiter) {
109        List<String> messages = new ArrayList<String>();
110
111        try {
112            makeProviderScmRepository(scmSpecificUrl, delimiter);
113        } catch (ScmRepositoryException e) {
114            messages.add(e.getMessage());
115        }
116
117        return messages;
118    }
119
120    /**
121     * {@inheritDoc}
122     */
123    @Override
124    public boolean requiresEditMode() {
125        return false;
126    }
127
128    // ----------------------------------------------------------------------
129    // Scm Implementation
130    // ----------------------------------------------------------------------
131
132    /**
133     * {@inheritDoc}
134     */
135    @Override
136    public AddScmResult add(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
137        return add(repository, fileSet, (String) null);
138    }
139
140    /**
141     * {@inheritDoc}
142     */
143    @Override
144    public AddScmResult add(ScmRepository repository, ScmFileSet fileSet, String message) throws ScmException {
145        login(repository, fileSet);
146
147        CommandParameters parameters = new CommandParameters();
148
149        parameters.setString(CommandParameter.MESSAGE, message == null ? "" : message);
150
151        // TODO: binary may be dependant on particular files though
152        // TODO: set boolean?
153        parameters.setString(CommandParameter.BINARY, "false");
154
155        return add(repository.getProviderRepository(), fileSet, parameters);
156    }
157
158    @Override
159    public AddScmResult add(ScmRepository repository, ScmFileSet fileSet, CommandParameters parameters)
160            throws ScmException {
161        login(repository, fileSet);
162
163        if (parameters.getString(CommandParameter.BINARY, null) == null) {
164            // TODO: binary may be dependant on particular files though
165            // TODO: set boolean?
166            parameters.setString(CommandParameter.BINARY, "false");
167        }
168
169        return add(repository.getProviderRepository(), fileSet, parameters);
170    }
171
172    /**
173     * TODO: why public? This should be protected, no?
174     */
175    public AddScmResult add(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
176            throws ScmException {
177        throw new NoSuchCommandScmException("add");
178    }
179
180    /**
181     * {@inheritDoc}
182     */
183    @Override
184    public BranchScmResult branch(ScmRepository repository, ScmFileSet fileSet, String branchName) throws ScmException {
185        return branch(repository, fileSet, branchName, new ScmBranchParameters());
186    }
187
188    /**
189     * {@inheritDoc}
190     */
191    @Override
192    public BranchScmResult branch(ScmRepository repository, ScmFileSet fileSet, String branchName, String message)
193            throws ScmException {
194        ScmBranchParameters scmBranchParameters = new ScmBranchParameters();
195
196        if (StringUtils.isNotEmpty(message)) {
197            scmBranchParameters.setMessage(message);
198        }
199
200        return branch(repository, fileSet, branchName, scmBranchParameters);
201    }
202
203    @Override
204    public BranchScmResult branch(
205            ScmRepository repository, ScmFileSet fileSet, String branchName, ScmBranchParameters scmBranchParameters)
206            throws ScmException {
207        login(repository, fileSet);
208
209        CommandParameters parameters = new CommandParameters();
210
211        parameters.setString(CommandParameter.BRANCH_NAME, branchName);
212
213        parameters.setScmBranchParameters(CommandParameter.SCM_BRANCH_PARAMETERS, scmBranchParameters);
214
215        return branch(repository.getProviderRepository(), fileSet, parameters);
216    }
217
218    protected BranchScmResult branch(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
219            throws ScmException {
220        throw new NoSuchCommandScmException("branch");
221    }
222
223    /**
224     * {@inheritDoc}
225     *
226     * @deprecated
227     */
228    @Deprecated
229    @Override
230    public ChangeLogScmResult changeLog(
231            ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate, int numDays, String branch)
232            throws ScmException {
233        return changeLog(repository, fileSet, startDate, endDate, numDays, branch, null);
234    }
235
236    /**
237     * {@inheritDoc}
238     *
239     * @deprecated
240     */
241    @Deprecated
242    @Override
243    public ChangeLogScmResult changeLog(
244            ScmRepository repository,
245            ScmFileSet fileSet,
246            Date startDate,
247            Date endDate,
248            int numDays,
249            String branch,
250            String datePattern)
251            throws ScmException {
252        ScmBranch scmBranch = null;
253
254        if (StringUtils.isNotEmpty(branch)) {
255            scmBranch = new ScmBranch(branch);
256        }
257        return changeLog(repository, fileSet, startDate, endDate, numDays, scmBranch, null);
258    }
259
260    /**
261     * {@inheritDoc}
262     */
263    @Override
264    public ChangeLogScmResult changeLog(
265            ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate, int numDays, ScmBranch branch)
266            throws ScmException {
267        return changeLog(repository, fileSet, startDate, endDate, numDays, branch, null);
268    }
269
270    /**
271     * {@inheritDoc}
272     */
273    @Override
274    public ChangeLogScmResult changeLog(
275            ScmRepository repository,
276            ScmFileSet fileSet,
277            Date startDate,
278            Date endDate,
279            int numDays,
280            ScmBranch branch,
281            String datePattern)
282            throws ScmException {
283        final ChangeLogScmRequest request = new ChangeLogScmRequest(repository, fileSet);
284        request.setDateRange(startDate, endDate);
285        request.setNumDays(numDays);
286        request.setScmBranch(branch);
287        request.setDatePattern(datePattern);
288        return changeLog(request);
289    }
290
291    /**
292     * {@inheritDoc}
293     */
294    @Override
295    public ChangeLogScmResult changeLog(ChangeLogScmRequest request) throws ScmException {
296        final ScmRepository scmRepository = request.getScmRepository();
297        final ScmFileSet scmFileSet = request.getScmFileSet();
298        login(scmRepository, scmFileSet);
299        return changelog(scmRepository.getProviderRepository(), scmFileSet, request.getCommandParameters());
300    }
301
302    /**
303     * {@inheritDoc}
304     *
305     * @deprecated
306     */
307    @Deprecated
308    @Override
309    public ChangeLogScmResult changeLog(ScmRepository repository, ScmFileSet fileSet, String startTag, String endTag)
310            throws ScmException {
311        return changeLog(repository, fileSet, startTag, endTag, null);
312    }
313
314    /**
315     * {@inheritDoc}
316     *
317     * @deprecated
318     */
319    @Deprecated
320    @Override
321    public ChangeLogScmResult changeLog(
322            ScmRepository repository, ScmFileSet fileSet, String startTag, String endTag, String datePattern)
323            throws ScmException {
324        ScmVersion startRevision = null;
325        ScmVersion endRevision = null;
326
327        if (StringUtils.isNotEmpty(startTag)) {
328            startRevision = new ScmRevision(startTag);
329        }
330
331        if (StringUtils.isNotEmpty(endTag)) {
332            endRevision = new ScmRevision(endTag);
333        }
334
335        return changeLog(repository, fileSet, startRevision, endRevision, null);
336    }
337
338    /**
339     * {@inheritDoc}
340     */
341    @Override
342    public ChangeLogScmResult changeLog(
343            ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion, ScmVersion endVersion)
344            throws ScmException {
345        return changeLog(repository, fileSet, startVersion, endVersion, null);
346    }
347
348    /**
349     * {@inheritDoc}
350     */
351    @Override
352    public ChangeLogScmResult changeLog(
353            ScmRepository repository,
354            ScmFileSet fileSet,
355            ScmVersion startVersion,
356            ScmVersion endVersion,
357            String datePattern)
358            throws ScmException {
359        login(repository, fileSet);
360
361        CommandParameters parameters = new CommandParameters();
362
363        parameters.setScmVersion(CommandParameter.START_SCM_VERSION, startVersion);
364
365        parameters.setScmVersion(CommandParameter.END_SCM_VERSION, endVersion);
366
367        parameters.setString(CommandParameter.CHANGELOG_DATE_PATTERN, datePattern);
368
369        return changelog(repository.getProviderRepository(), fileSet, parameters);
370    }
371
372    protected ChangeLogScmResult changelog(
373            ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters) throws ScmException {
374        throw new NoSuchCommandScmException("changelog");
375    }
376
377    /**
378     * {@inheritDoc}
379     *
380     * @deprecated
381     */
382    @Deprecated
383    @Override
384    public CheckInScmResult checkIn(ScmRepository repository, ScmFileSet fileSet, String tag, String message)
385            throws ScmException {
386        ScmVersion scmVersion = null;
387
388        if (StringUtils.isNotEmpty(tag)) {
389            scmVersion = new ScmBranch(tag);
390        }
391
392        return checkIn(repository, fileSet, scmVersion, message);
393    }
394
395    /**
396     * {@inheritDoc}
397     */
398    @Override
399    public CheckInScmResult checkIn(ScmRepository repository, ScmFileSet fileSet, String message) throws ScmException {
400        return checkIn(repository, fileSet, (ScmVersion) null, message);
401    }
402
403    /**
404     * {@inheritDoc}
405     */
406    @Override
407    public CheckInScmResult checkIn(ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, String message)
408            throws ScmException {
409        login(repository, fileSet);
410
411        CommandParameters parameters = new CommandParameters();
412
413        parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
414
415        parameters.setString(CommandParameter.MESSAGE, message);
416
417        return checkin(repository.getProviderRepository(), fileSet, parameters);
418    }
419
420    protected CheckInScmResult checkin(
421            ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters) throws ScmException {
422        throw new NoSuchCommandScmException("checkin");
423    }
424
425    /**
426     * {@inheritDoc}
427     *
428     * @deprecated
429     */
430    @Deprecated
431    @Override
432    public CheckOutScmResult checkOut(ScmRepository repository, ScmFileSet fileSet, String tag) throws ScmException {
433        return checkOut(repository, fileSet, tag, true);
434    }
435
436    /**
437     * {@inheritDoc}
438     *
439     * @deprecated
440     */
441    @Deprecated
442    @Override
443    public CheckOutScmResult checkOut(ScmRepository repository, ScmFileSet fileSet, String tag, boolean recursive)
444            throws ScmException {
445        ScmVersion scmVersion = null;
446
447        if (StringUtils.isNotEmpty(tag)) {
448            scmVersion = new ScmBranch(tag);
449        }
450
451        return checkOut(repository, fileSet, scmVersion, recursive);
452    }
453
454    /**
455     * {@inheritDoc}
456     */
457    @Override
458    public CheckOutScmResult checkOut(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
459        return checkOut(repository, fileSet, (ScmVersion) null, true);
460    }
461
462    /**
463     * {@inheritDoc}
464     */
465    @Override
466    public CheckOutScmResult checkOut(ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion)
467            throws ScmException {
468        return checkOut(repository, fileSet, scmVersion, true);
469    }
470
471    /**
472     * {@inheritDoc}
473     */
474    @Override
475    public CheckOutScmResult checkOut(ScmRepository repository, ScmFileSet fileSet, boolean recursive)
476            throws ScmException {
477        return checkOut(repository, fileSet, (ScmVersion) null, recursive);
478    }
479
480    /**
481     * {@inheritDoc}
482     */
483    @Override
484    public CheckOutScmResult checkOut(
485            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, boolean recursive)
486            throws ScmException {
487        login(repository, fileSet);
488
489        CommandParameters parameters = new CommandParameters();
490
491        parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
492
493        parameters.setString(CommandParameter.RECURSIVE, Boolean.toString(recursive));
494
495        return checkout(repository.getProviderRepository(), fileSet, parameters);
496    }
497
498    @Override
499    public CheckOutScmResult checkOut(
500            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, CommandParameters commandParameters)
501            throws ScmException {
502        login(repository, fileSet);
503        if (scmVersion != null && commandParameters.getScmVersion(CommandParameter.SCM_VERSION, null) == null) {
504            commandParameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
505        }
506
507        return checkout(repository.getProviderRepository(), fileSet, commandParameters);
508    }
509
510    protected CheckOutScmResult checkout(
511            ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters) throws ScmException {
512        throw new NoSuchCommandScmException("checkout");
513    }
514
515    /**
516     * {@inheritDoc}
517     *
518     * @deprecated
519     */
520    @Deprecated
521    @Override
522    public DiffScmResult diff(ScmRepository repository, ScmFileSet fileSet, String startRevision, String endRevision)
523            throws ScmException {
524        ScmVersion startVersion = null;
525        ScmVersion endVersion = null;
526
527        if (StringUtils.isNotEmpty(startRevision)) {
528            startVersion = new ScmRevision(startRevision);
529        }
530
531        if (StringUtils.isNotEmpty(endRevision)) {
532            endVersion = new ScmRevision(endRevision);
533        }
534
535        return diff(repository, fileSet, startVersion, endVersion);
536    }
537
538    /**
539     * {@inheritDoc}
540     */
541    @Override
542    public DiffScmResult diff(
543            ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion, ScmVersion endVersion)
544            throws ScmException {
545        login(repository, fileSet);
546
547        CommandParameters parameters = new CommandParameters();
548
549        parameters.setScmVersion(CommandParameter.START_SCM_VERSION, startVersion);
550
551        parameters.setScmVersion(CommandParameter.END_SCM_VERSION, endVersion);
552
553        return diff(repository.getProviderRepository(), fileSet, parameters);
554    }
555
556    protected DiffScmResult diff(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
557            throws ScmException {
558        throw new NoSuchCommandScmException("diff");
559    }
560
561    /**
562     * {@inheritDoc}
563     */
564    @Override
565    public EditScmResult edit(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
566        login(repository, fileSet);
567
568        CommandParameters parameters = new CommandParameters();
569
570        return edit(repository.getProviderRepository(), fileSet, parameters);
571    }
572
573    protected EditScmResult edit(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
574            throws ScmException {
575        if (logger.isWarnEnabled()) {
576            logger.warn("Provider " + this.getScmType() + " does not support edit operation.");
577        }
578
579        return new EditScmResult("", null, null, true);
580    }
581
582    /**
583     * {@inheritDoc}
584     *
585     * @deprecated
586     */
587    @Deprecated
588    @Override
589    public ExportScmResult export(ScmRepository repository, ScmFileSet fileSet, String tag) throws ScmException {
590        return export(repository, fileSet, tag, null);
591    }
592
593    /**
594     * {@inheritDoc}
595     *
596     * @deprecated
597     */
598    @Deprecated
599    @Override
600    public ExportScmResult export(ScmRepository repository, ScmFileSet fileSet, String tag, String outputDirectory)
601            throws ScmException {
602        ScmVersion scmVersion = null;
603
604        if (StringUtils.isNotEmpty(tag)) {
605            scmVersion = new ScmRevision(tag);
606        }
607
608        return export(repository, fileSet, scmVersion, outputDirectory);
609    }
610
611    /**
612     * {@inheritDoc}
613     */
614    @Override
615    public ExportScmResult export(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
616        return export(repository, fileSet, (ScmVersion) null, null);
617    }
618
619    /**
620     * {@inheritDoc}
621     */
622    @Override
623    public ExportScmResult export(ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion)
624            throws ScmException {
625        return export(repository, fileSet, scmVersion, null);
626    }
627
628    /**
629     * {@inheritDoc}
630     */
631    @Override
632    public ExportScmResult export(
633            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, String outputDirectory)
634            throws ScmException {
635        login(repository, fileSet);
636
637        CommandParameters parameters = new CommandParameters();
638
639        parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
640
641        parameters.setString(CommandParameter.OUTPUT_DIRECTORY, outputDirectory);
642
643        return export(repository.getProviderRepository(), fileSet, parameters);
644    }
645
646    protected ExportScmResult export(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
647            throws ScmException {
648        throw new NoSuchCommandScmException("export");
649    }
650
651    /**
652     * {@inheritDoc}
653     */
654    @Override
655    public ListScmResult list(ScmRepository repository, ScmFileSet fileSet, boolean recursive, String tag)
656            throws ScmException {
657        ScmVersion scmVersion = null;
658
659        if (StringUtils.isNotEmpty(tag)) {
660            scmVersion = new ScmRevision(tag);
661        }
662
663        return list(repository, fileSet, recursive, scmVersion);
664    }
665
666    /**
667     * {@inheritDoc}
668     */
669    @Override
670    public ListScmResult list(ScmRepository repository, ScmFileSet fileSet, boolean recursive, ScmVersion scmVersion)
671            throws ScmException {
672        login(repository, fileSet);
673
674        CommandParameters parameters = new CommandParameters();
675
676        parameters.setString(CommandParameter.RECURSIVE, Boolean.toString(recursive));
677
678        if (scmVersion != null) {
679            parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
680        }
681
682        return list(repository.getProviderRepository(), fileSet, parameters);
683    }
684
685    /**
686     * List each element (files and directories) of <B>fileSet</B> as they exist in the repository.
687     *
688     * @param repository the source control system
689     * @param fileSet    the files to list
690     * @param parameters TODO
691     * @return The list of files in the repository
692     * @throws NoSuchCommandScmException unless overriden by subclass
693     * @throws ScmException              if any
694     */
695    protected ListScmResult list(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
696            throws ScmException {
697        throw new NoSuchCommandScmException("list");
698    }
699
700    /**
701     * {@inheritDoc}
702     */
703    @Override
704    public MkdirScmResult mkdir(ScmRepository repository, ScmFileSet fileSet, String message, boolean createInLocal)
705            throws ScmException {
706        login(repository, fileSet);
707
708        CommandParameters parameters = new CommandParameters();
709
710        if (message == null) {
711            message = "";
712            if (!createInLocal) {
713                logger.warn("Commit message is empty!");
714            }
715        }
716
717        parameters.setString(CommandParameter.MESSAGE, message);
718
719        parameters.setString(CommandParameter.SCM_MKDIR_CREATE_IN_LOCAL, Boolean.toString(createInLocal));
720
721        return mkdir(repository.getProviderRepository(), fileSet, parameters);
722    }
723
724    /**
725     * Create directory/directories in the repository.
726     *
727     * @param repository TODO
728     * @param fileSet TODO
729     * @param parameters TODO
730     * @return TODO
731     * @throws ScmException if any
732     */
733    protected MkdirScmResult mkdir(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
734            throws ScmException {
735        throw new NoSuchCommandScmException("mkdir");
736    }
737
738    private void login(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
739        LoginScmResult result = login(repository.getProviderRepository(), fileSet, new CommandParameters());
740
741        if (!result.isSuccess()) {
742            throw new ScmException("Can't login.\n" + result.getCommandOutput());
743        }
744    }
745
746    protected LoginScmResult login(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
747            throws ScmException {
748        return new LoginScmResult(null, null, null, true);
749    }
750
751    /**
752     * {@inheritDoc}
753     */
754    @Override
755    public RemoveScmResult remove(ScmRepository repository, ScmFileSet fileSet, String message) throws ScmException {
756        login(repository, fileSet);
757
758        CommandParameters parameters = new CommandParameters();
759
760        parameters.setString(CommandParameter.MESSAGE, message == null ? "" : message);
761
762        return remove(repository.getProviderRepository(), fileSet, parameters);
763    }
764
765    protected RemoveScmResult remove(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
766            throws ScmException {
767        throw new NoSuchCommandScmException("remove");
768    }
769
770    /**
771     * {@inheritDoc}
772     */
773    @Override
774    public StatusScmResult status(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
775        login(repository, fileSet);
776
777        CommandParameters parameters = new CommandParameters();
778
779        return status(repository.getProviderRepository(), fileSet, parameters);
780    }
781
782    protected StatusScmResult status(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
783            throws ScmException {
784        throw new NoSuchCommandScmException("status");
785    }
786
787    /**
788     * {@inheritDoc}
789     */
790    @Override
791    public TagScmResult tag(ScmRepository repository, ScmFileSet fileSet, String tagName) throws ScmException {
792        return tag(repository, fileSet, tagName, new ScmTagParameters());
793    }
794
795    /**
796     * {@inheritDoc}
797     */
798    @Override
799    public TagScmResult tag(ScmRepository repository, ScmFileSet fileSet, String tagName, String message)
800            throws ScmException {
801        login(repository, fileSet);
802
803        CommandParameters parameters = new CommandParameters();
804
805        parameters.setString(CommandParameter.TAG_NAME, tagName);
806
807        if (StringUtils.isNotEmpty(message)) {
808            parameters.setString(CommandParameter.MESSAGE, message);
809        }
810
811        ScmTagParameters scmTagParameters = new ScmTagParameters(message);
812
813        parameters.setScmTagParameters(CommandParameter.SCM_TAG_PARAMETERS, scmTagParameters);
814
815        return tag(repository.getProviderRepository(), fileSet, parameters);
816    }
817
818    /**
819     * {@inheritDoc}
820     */
821    @Override
822    public TagScmResult tag(
823            ScmRepository repository, ScmFileSet fileSet, String tagName, ScmTagParameters scmTagParameters)
824            throws ScmException {
825        login(repository, fileSet);
826
827        CommandParameters parameters = new CommandParameters();
828
829        parameters.setString(CommandParameter.TAG_NAME, tagName);
830
831        parameters.setScmTagParameters(CommandParameter.SCM_TAG_PARAMETERS, scmTagParameters);
832
833        return tag(repository.getProviderRepository(), fileSet, parameters);
834    }
835
836    protected TagScmResult tag(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
837            throws ScmException {
838        throw new NoSuchCommandScmException("tag");
839    }
840
841    /**
842     * {@inheritDoc}
843     */
844    @Override
845    public UnEditScmResult unedit(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
846        login(repository, fileSet);
847
848        CommandParameters parameters = new CommandParameters();
849
850        return unedit(repository.getProviderRepository(), fileSet, parameters);
851    }
852
853    protected UnEditScmResult unedit(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
854            throws ScmException {
855        if (logger.isWarnEnabled()) {
856            logger.warn("Provider " + this.getScmType() + " does not support unedit operation.");
857        }
858
859        return new UnEditScmResult("", null, null, true);
860    }
861
862    /**
863     * {@inheritDoc}
864     */
865    @Override
866    public UntagScmResult untag(ScmRepository repository, ScmFileSet fileSet, CommandParameters parameters)
867            throws ScmException {
868        logger.warn("Provider " + this.getScmType() + " does not support untag operation.");
869        return new UntagScmResult("", null, null, true);
870    }
871
872    /**
873     * {@inheritDoc}
874     *
875     * @deprecated
876     */
877    @Deprecated
878    @Override
879    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, String tag) throws ScmException {
880        return update(repository, fileSet, tag, true);
881    }
882
883    /**
884     * {@inheritDoc}
885     *
886     * @deprecated
887     */
888    @Deprecated
889    @Override
890    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, String tag, boolean runChangelog)
891            throws ScmException {
892        return update(repository, fileSet, tag, "", runChangelog);
893    }
894
895    /**
896     * {@inheritDoc}
897     */
898    @Override
899    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet) throws ScmException {
900        return update(repository, fileSet, (ScmVersion) null, true);
901    }
902
903    /**
904     * {@inheritDoc}
905     */
906    @Override
907    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion)
908            throws ScmException {
909        return update(repository, fileSet, scmVersion, true);
910    }
911
912    /**
913     * {@inheritDoc}
914     */
915    @Override
916    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, boolean runChangelog)
917            throws ScmException {
918        return update(repository, fileSet, (ScmVersion) null, "", runChangelog);
919    }
920
921    /**
922     * {@inheritDoc}
923     */
924    @Override
925    public UpdateScmResult update(
926            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, boolean runChangelog)
927            throws ScmException {
928        return update(repository, fileSet, scmVersion, "", runChangelog);
929    }
930
931    /**
932     * {@inheritDoc}
933     *
934     * @deprecated
935     */
936    @Override
937    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, String tag, String datePattern)
938            throws ScmException {
939        return update(repository, fileSet, tag, datePattern, true);
940    }
941
942    /**
943     * {@inheritDoc}
944     */
945    @Override
946    public UpdateScmResult update(
947            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, String datePattern)
948            throws ScmException {
949        return update(repository, fileSet, scmVersion, datePattern, true);
950    }
951
952    /**
953     * @deprecated
954     */
955    private UpdateScmResult update(
956            ScmRepository repository, ScmFileSet fileSet, String tag, String datePattern, boolean runChangelog)
957            throws ScmException {
958        ScmBranch scmBranch = null;
959
960        if (StringUtils.isNotEmpty(tag)) {
961            scmBranch = new ScmBranch(tag);
962        }
963
964        return update(repository, fileSet, scmBranch, datePattern, runChangelog);
965    }
966
967    private UpdateScmResult update(
968            ScmRepository repository,
969            ScmFileSet fileSet,
970            ScmVersion scmVersion,
971            String datePattern,
972            boolean runChangelog)
973            throws ScmException {
974        login(repository, fileSet);
975
976        CommandParameters parameters = new CommandParameters();
977
978        parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
979
980        parameters.setString(CommandParameter.CHANGELOG_DATE_PATTERN, datePattern);
981
982        parameters.setString(CommandParameter.RUN_CHANGELOG_WITH_UPDATE, String.valueOf(runChangelog));
983
984        return update(repository.getProviderRepository(), fileSet, parameters);
985    }
986
987    /**
988     * {@inheritDoc}
989     *
990     * @deprecated
991     */
992    @Deprecated
993    @Override
994    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, String tag, Date lastUpdate)
995            throws ScmException {
996        return update(repository, fileSet, tag, lastUpdate, null);
997    }
998
999    /**
1000     * {@inheritDoc}
1001     */
1002    @Override
1003    public UpdateScmResult update(ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, Date lastUpdate)
1004            throws ScmException {
1005        return update(repository, fileSet, scmVersion, lastUpdate, null);
1006    }
1007
1008    /**
1009     * {@inheritDoc}
1010     *
1011     * @deprecated
1012     */
1013    @Deprecated
1014    @Override
1015    public UpdateScmResult update(
1016            ScmRepository repository, ScmFileSet fileSet, String tag, Date lastUpdate, String datePattern)
1017            throws ScmException {
1018        ScmBranch scmBranch = null;
1019
1020        if (StringUtils.isNotEmpty(tag)) {
1021            scmBranch = new ScmBranch(tag);
1022        }
1023
1024        return update(repository, fileSet, scmBranch, lastUpdate, datePattern);
1025    }
1026
1027    /**
1028     * {@inheritDoc}
1029     */
1030    @Override
1031    public UpdateScmResult update(
1032            ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, Date lastUpdate, String datePattern)
1033            throws ScmException {
1034        login(repository, fileSet);
1035
1036        CommandParameters parameters = new CommandParameters();
1037
1038        parameters.setScmVersion(CommandParameter.SCM_VERSION, scmVersion);
1039
1040        if (lastUpdate != null) {
1041            parameters.setDate(CommandParameter.START_DATE, lastUpdate);
1042        }
1043
1044        parameters.setString(CommandParameter.CHANGELOG_DATE_PATTERN, datePattern);
1045
1046        parameters.setString(CommandParameter.RUN_CHANGELOG_WITH_UPDATE, "true");
1047
1048        return update(repository.getProviderRepository(), fileSet, parameters);
1049    }
1050
1051    protected UpdateScmResult update(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
1052            throws ScmException {
1053        throw new NoSuchCommandScmException("update");
1054    }
1055
1056    /**
1057     * {@inheritDoc}
1058     */
1059    @Override
1060    public BlameScmResult blame(ScmRepository repository, ScmFileSet fileSet, String filename) throws ScmException {
1061        login(repository, fileSet);
1062
1063        CommandParameters parameters = new CommandParameters();
1064
1065        parameters.setString(CommandParameter.FILE, filename);
1066
1067        return blame(repository.getProviderRepository(), fileSet, parameters);
1068    }
1069
1070    protected BlameScmResult blame(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
1071            throws ScmException {
1072        throw new NoSuchCommandScmException("blame");
1073    }
1074
1075    @Override
1076    public BlameScmResult blame(BlameScmRequest blameScmRequest) throws ScmException {
1077        return blame(
1078                blameScmRequest.getScmRepository().getProviderRepository(),
1079                blameScmRequest.getScmFileSet(),
1080                blameScmRequest.getCommandParameters());
1081    }
1082
1083    @Override
1084    public InfoScmResult info(ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
1085            throws ScmException {
1086        return null;
1087    }
1088
1089    @Override
1090    public RemoteInfoScmResult remoteInfo(
1091            ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters) throws ScmException {
1092        return null;
1093    }
1094
1095    /**
1096     * {@inheritDoc}
1097     */
1098    @Override
1099    public ScmProviderRepository makeProviderScmRepository(File path)
1100            throws ScmRepositoryException, UnknownRepositoryStructure {
1101        throw new UnknownRepositoryStructure();
1102    }
1103}