ScmService

Creates a ScmCommandBuilder which can be used to construct free-form commands to interact directly with the underlying SCM implementation and perform custom functions on repositories.

Command builders are provided as a very powerful extension point for plugin developers, allowing them to create new functionality that uses commands the application does not, or uses them in different ways. However, plugin developers should be aware that:

• The system may support multiple versions of an SCM, and those versions may support different commands and/or arguments, and even the "same" command may produce different output between versions
• In a free-form builder, the command and arguments are not checked until the command is run; the system does not, and cannot, validate that the arguments are correct in advance
• Above all, the system cannot verify the safety of commands being executed; plugin developers must apply due diligence to ensure the operations they perform do not damage the repository

The created ScmCommandBuilder will use the provided repository's directory as its initial working directory. After the builder has been created, it is possible to change the working directory on the instance, before commands are constructed.

Note: Per the contract of the ScmCommandBuilder API, the returned builder is not thread-safe. If multiple threads require use of a builder, each thread should always create its own builder.

Retrieves the set of available SCMs. SCMs that are installed but not in a good state will not be included in the returned set. The returned set will never be empty; the system requires at least one available SCM or it will be locked out on startup.

Each SCM implementation is different, but examples of reasons why an installed SCM might not be available include:

• The binary associated with the SCM, such as git or hg, may not be installed
• The installed binary might be of an unsupported version, too old or too new
• Another plugin the SCM depends on may not be installed or may be disabled

Retrieves an ScmBulkContentCommandFactory, used to create commands for retrieving bulk data from the SCM.

SCMs are not required to implement support for bulk commands. However, an SCM which does support them may be capable of significantly increased efficiency when performing large operations.

Note: Since 5.8, this method will no longer throw FeatureUnsupportedScmException. Instead, an exception will be thrown when trying to create a specific command, if the SCM doesn't support it. Prior to 5.8, since ScmBulkContentCommandFactory only supported a single command, the associated feature could be eagerly checked when retrieving the factory. Now that it offers multiple commands, features must be checked when commands are requested instead.

Retrieves an ScmCommandFactory, used to create commands for performing standard SCM operations such as retrieving commits and viewing diffs.

Retrieves an ScmCompareCommandFactory, used to create commands tailored for comparing refs.

This differs from the normal getCommandFactory(Repository) in that any comparison will be rooted into the closest common ancestor between the refs. In other words, any comparison will be one sided and only includes the changes the source ref would bring to the target ref if they were merged.

Retrieves an ScmExtendedCommandFactory, used to create commands for extended SCM functionality.

SCMs are not required to implement support for any of the commands on this factory, and implementing support for any one command does not require supporting any other command. Attempting to use a command which has not been implemented by the SCM will trigger a FeatureUnsupportedScmException. Callers should check support prior to using any command on this factory. Each command is associated with its own feature. The mapping between features and commands is documented on the ScmExtendedCommandFactory interface.

Note: Unlike other command factories, like the pull request command factory, calling this method will never throw a FeatureUnsupportedScmException. Feature support is checked against each method on the returned factory, not against retrieving the factory itself.

Retrieves a ScmHookHandlerFactory, used to create hook handlers that manage scm hook callbacks.

SCMs are not required to implement support for SCM hooks.

Retrieves an ScmMirrorCommandFactory, used to create commands tailored for mirroring repositories.

SCMs are not required to implement support for mirroring.

Retrieves an ScmPullRequestCommandFactory, used to create commands tailored for use operating on pull requests.

SCMs are not required to implement support for pull requests.

Retrieves an ScmRefCommandFactory, used to create commands tailored for creating branches and tags.

SCMs are not required to implement support for creating branches or tags.

Retrieves the name for the SCM which powers the specified repository.

Calculates the size (in bytes) for the specified repository. If the provided Repository does not exist, its size is always 0.

Note: Calculating the size can be an expensive operation. The returned value may be a best effort estimation of the repository size.

Tests whether the specified Repository is empty.

Tests whether the SCM for the specified Repository supports the requested feature.

Tests whether the specified SCM supports the requested feature.