Difference between revisions of "Documentation/Nightly/Developers/ExtensionWizard"

From Slicer Wiki
Jump to: navigation, search
(add documentation for contributing extensions, plus other minor tweaks)
Line 14: Line 14:
 
=== Requirements ===
 
=== Requirements ===
  
* [http://www.python.org/ Python] >= 2.5 ('python' should be in your $PATH)
+
* [http://www.python.org/ Python] ≥ 2.6 ('python' should be in your $PATH)
* [http://git-scm.com git] (use [http://msysgit.github.io/ msys git] on Windows)
+
* [http://git-scm.com git] ≥ 1.7.10 (use [http://msysgit.github.io/ msys git] on Windows)
* [https://github.com/gitpython-developers/GitPython/ GitPython]
+
* [http://github.com/gitpython-developers/GitPython/ GitPython]
 
* [http://jacquev6.github.io/PyGithub/ PyGithub]
 
* [http://jacquev6.github.io/PyGithub/ PyGithub]
  
Line 38: Line 38:
 
  # List available templates
 
  # List available templates
 
  ExtensionWizard.py --listTemplates
 
  ExtensionWizard.py --listTemplates
   
+
  <nowiki/>
 
  # Create an extension with two modules; one written in C++, and one in Python
 
  # Create an extension with two modules; one written in C++, and one in Python
 
  ExtensionWizard.py --create MyExtension ~/code/
 
  ExtensionWizard.py --create MyExtension ~/code/
Line 44: Line 44:
 
  ExtensionWizard.py --addModule loadable:MyCppModule
 
  ExtensionWizard.py --addModule loadable:MyCppModule
 
  ExtensionWizard.py --addModule scripted:MyPythonModule
 
  ExtensionWizard.py --addModule scripted:MyPythonModule
   
+
  <nowiki/>
 
  # Create a superbuild extension with a CLI module
 
  # Create a superbuild extension with a CLI module
 
  ExtensionWizard.py --create superbuild:MyCLIExtension ~/code/
 
  ExtensionWizard.py --create superbuild:MyCLIExtension ~/code/
Line 112: Line 112:
 
  # a template type, e.g. 'modules'
 
  # a template type, e.g. 'modules'
 
  ExtensionWizard.py --templatePath ~/code/Templates
 
  ExtensionWizard.py --templatePath ~/code/Templates
   
+
  <nowiki/>
 
  # Add custom module templates
 
  # Add custom module templates
 
  ExtensionWizard.py --templatePath modules=~/code/Templates
 
  ExtensionWizard.py --templatePath modules=~/code/Templates
Line 119: Line 119:
  
 
Note that these options apply only to the invocation of the wizard for which they are used.
 
Note that these options apply only to the invocation of the wizard for which they are used.
 +
 +
== Contributing Extensions ==
 +
 +
Once your extension is in a state that you want to make it available via Slicer's public [http://slicer.kitware.com/midas3/slicerappstore Extensions Catalog], you'll need to do two things:
 +
 +
# "Publish" your extension by making it available on a publicly accessible repository.
 +
# Request that your extension be added to the [http://github.com/Slicer/ExtensionsIndex public extension index].
 +
 +
Before you begin, you'll need a [http://github.com github] account.
 +
 +
The wizard uses [http://git-scm.com/docs/gitcredentials.html git credentials] to manage your user name and password. This means it will e.g. honor <code>$GIT_ASKPASS</code> when git would, and cache your login information if git is configured to do so.
 +
 +
If you aren't using a password manager and want git to remember your user name, you may wish to run:
 +
 +
git config ''[''--global'']'' <nowiki>credential.https://github.com.username</nowiki> ''<your_user_name>''
 +
 +
=== Publishing Extensions ===
 +
 +
The Extension Wizard can be used to publish your extension to a github repository:
 +
 +
ExtensionWizard.py --publish ~/code/MyExtension
 +
 +
This will:
 +
 +
* Create a git repository, if your extension is not already managed by git.
 +
* Create a github repository for your extension and add this as a remote of your local repository.
 +
* Update your extension information so that the homepage and icon URL refer to the github repository.
 +
* Commit the above changes (or make an initial commit, if you didn't already have a git repository).
 +
* Push your extension to the github repository.
 +
 +
{{notice|You should not use this command if your extension already has a public repository and/or is using Subversion for source code management.}}
 +
 +
Once your extension has a public repository, you should commit (svn) or push (git) changes using your SCM tool's usual workflow.
 +
 +
This command is intended to be used on new extensions, especially those created using the wizard (which initially have a placeholder homepage). If your extension already has a separate homepage that you would like to continue to use, you may wish to do the following after publishing:
 +
 +
vi CMakeLists.txt # or use your favorite editor to restore the old homepage
 +
git add -p CMakeLists.txt
 +
git commit --amend # Don't have other files staged when you do this!
 +
git push origin +HEAD
 +
 +
This will amend the commit which changed your extension information and force-push the change to your new public github repository.
 +
 +
=== Contributing Extensions to the Index ===
 +
 +
When your extension is ready for wider distribution/use, you can request that it be added to the public extension catalog. To do this, run:
 +
 +
# First check that your extension description looks okay:
 +
ExtensionWizard.py --describe ~/code/MyExtension
 +
<nowiki/>
 +
# If it does:
 +
ExtensionWizard.py --contribute --target master ~/code/MyExtension
 +
 +
This will fork and clone the [http://github.com/Slicer/ExtensionsIndex extension index repository], add your extension description, and create a pull request to merge your addition to the index to the primary (upstream) index. If your extension already exists, the description is instead updated, and the pull request will include a link to the changes that have been made to your extension since the existing upstream version.
 +
 +
The <code>--target</code> option may be used to specify the branch of slicer for which your extension is intended, e.g. <code>4.3</code>. This parameter is optional, defaulting to <code>master</code>.
 +
 +
By default, the extension index is cloned to a directory inside the <code>.git</code> directory of your extension. The <code>--index</code> option may be used to specify an alternate location or existing extension index clone.

Revision as of 19:25, 7 February 2014

Home < Documentation < Nightly < Developers < ExtensionWizard

Overview

This page describes the Slicer Extension Wizard. To avoid redundancy and reduce the effort needed to maintain this page, generic usage is not provided here; run the wizard with the --help option instead.

Background

Slicer modules typically consist of several files of various types, such as CMake files, source files, and resource files. In many cases, the names of the files and the names of text strings inside the files are related and need to be in sync in order for things to compile. An extension encapsulates one or mode modules (which can be of different types) in a package that can be loaded by Slicer.

The Extension Wizard is a tool to simplify the process of creating and contributing extensions.

Requirements

You should also ensure that the python interpreter ('python') is in your $PATH. On Windows, using the wizard from an msys git prompt is recommended.

Note that you do not need to use the version of Python that is built with Slicer.

Creating Extensions

The Extension Wizard simplifies the process of creating extensions by providing a mechanism to create extensions and modules from templates. This process will automatically create files for you with appropriate names, and make some crucial content substitutions within the templates in order to produce code that can be built immediately.

Terminology

template 
A directory containing files that are used to create a new entity (e.g. extension or module).
templateKey 
A text string that is used in both filename and identifiers inside the module. For Slicer-provided extensions, this is "TemplateKey".
destination 
The directory under which you want the new code to be placed.
name 
The name of the new entity (e.g. extension, module) you want to create. The code will be placed in a subdirectory by this name, and the templateKey will be replaced with this name.

Examples

# List available templates
ExtensionWizard.py --listTemplates

# Create an extension with two modules; one written in C++, and one in Python
ExtensionWizard.py --create MyExtension ~/code/
cd ~/code/MyExtension
ExtensionWizard.py --addModule loadable:MyCppModule
ExtensionWizard.py --addModule scripted:MyPythonModule

# Create a superbuild extension with a CLI module
ExtensionWizard.py --create superbuild:MyCLIExtension ~/code/
ExtensionWizard.py --addModule cli:MyCLI ~/code/MyCLIExtension

The wizard attempts to update your extension CMakeLists.txt to build the new module. The stock module templates include a placeholder which indicates where the new add_subdirectory should be inserted. (If this placeholder is not present, the wizard attempts to add the new add_subdirectory after the last existing add_subdirectory.)

Note that the destination (extension) directory is optional, defaulting to the current directory. In the above example, we cd into the newly created extension directory, which allows us to omit this argument for subsequent operations.

Now is a good time to create a git repository to keep track of your work:

cd ~/code/MyExtension
git init .
git add .
git commit

After creating your extension or adding modules, you should edit the newly created files to update the extension or module information with your name, an appropriate destination, and any acknowledgments. You may also wish to replace the extension icon with a 128x128 icon of your choosing.

Using Extensions

Building

If your extension is not pure Python, you will need to compile it in order to use it. (Even if it is, you may wish to build your extension in order to use it from the build tree.)

To build your extension:

Slicer_DIR=/path/to/slicer/superbuild
cd ~/code/MyExtension
mkdir build
cd build
cmake -DSlicer_DIR:PATH=${Slicer_DIR} ..
cmake --build .


"Installation"

You don't need to "install" your extension, as such, but you do need to tell Slicer where to find it. After building your extension (if needed; you can skip this for pure-Python extensions), open Slicer's Application Settings dialog, select "Modules" from the list, and add additional module paths to point to the full path to your extension. For example:

  • ~/code/MyExtension/build/lib/Slicer-<version>/qt-loadable-modules
  • ~/code/MyExtension/build/lib/Slicer-<version>/qt-scripted-modules
  • ~/code/MyExtension/MyPythonModule

The second item above is used for Python modules if you are building your extension (which may be convenient if you have several modules). The third item references a single Python module directly from the source tree. For a given extension, you should use one form or the other; not both.

After restarting Slicer, your module should show up in the Module Navigation interface.

Stock Templates

The following templates are provided with Slicer:

Extensions

default 
A basic extension.
superbuild 
An extension which is intended to be integrated with a Slicer superbuild.

Modules

cli 
A module which provides a custom command line interface.
loadable 
A C++ module which provides new functionality in Slicer.
scripted 
A Python module which provides new functionality in Slicer.

Using Custom Templates

By default, the Extension Wizard uses a set of templates that are provided with Slicer. You can add your own templates with the --templatePath parameter:

# Add custom templates; expects to find subdirectories under the path matching
# a template type, e.g. 'modules'
ExtensionWizard.py --templatePath ~/code/Templates

# Add custom module templates
ExtensionWizard.py --templatePath modules=~/code/Templates

This can also be used to make a copy of an existing module. When doing so, you will likely also want to use the --templateKey option to specify the text that should be replaced when making the copy.

Note that these options apply only to the invocation of the wizard for which they are used.

Contributing Extensions

Once your extension is in a state that you want to make it available via Slicer's public Extensions Catalog, you'll need to do two things:

  1. "Publish" your extension by making it available on a publicly accessible repository.
  2. Request that your extension be added to the public extension index.

Before you begin, you'll need a github account.

The wizard uses git credentials to manage your user name and password. This means it will e.g. honor $GIT_ASKPASS when git would, and cache your login information if git is configured to do so.

If you aren't using a password manager and want git to remember your user name, you may wish to run:

git config [--global] credential.https://github.com.username <your_user_name>

Publishing Extensions

The Extension Wizard can be used to publish your extension to a github repository:

ExtensionWizard.py --publish ~/code/MyExtension

This will:

  • Create a git repository, if your extension is not already managed by git.
  • Create a github repository for your extension and add this as a remote of your local repository.
  • Update your extension information so that the homepage and icon URL refer to the github repository.
  • Commit the above changes (or make an initial commit, if you didn't already have a git repository).
  • Push your extension to the github repository.

Once your extension has a public repository, you should commit (svn) or push (git) changes using your SCM tool's usual workflow.

This command is intended to be used on new extensions, especially those created using the wizard (which initially have a placeholder homepage). If your extension already has a separate homepage that you would like to continue to use, you may wish to do the following after publishing:

vi CMakeLists.txt # or use your favorite editor to restore the old homepage
git add -p CMakeLists.txt
git commit --amend # Don't have other files staged when you do this!
git push origin +HEAD

This will amend the commit which changed your extension information and force-push the change to your new public github repository.

Contributing Extensions to the Index

When your extension is ready for wider distribution/use, you can request that it be added to the public extension catalog. To do this, run:

# First check that your extension description looks okay:
ExtensionWizard.py --describe ~/code/MyExtension

# If it does:
ExtensionWizard.py --contribute --target master ~/code/MyExtension

This will fork and clone the extension index repository, add your extension description, and create a pull request to merge your addition to the index to the primary (upstream) index. If your extension already exists, the description is instead updated, and the pull request will include a link to the changes that have been made to your extension since the existing upstream version.

The --target option may be used to specify the branch of slicer for which your extension is intended, e.g. 4.3. This parameter is optional, defaulting to master.

By default, the extension index is cloned to a directory inside the .git directory of your extension. The --index option may be used to specify an alternate location or existing extension index clone.