DevAssistant is developer’s best friend (right after coffee).
DevAssistant can help you with creating and setting up basic projects in various languages, installing dependencies, setting up environment etc. There are three main types of functionality provided:
DevAssistant is based on idea of per-{language/framework/...} “assistants” with hierarchical structure. E.g. you can run:
$ da crt python django -n ~/myproject # sets up Django project named "myproject" inside your home dir
$ da crt python flask -n ~/flaskproject # sets up Flask project named "flaskproject" inside your home dir
$ da crt ruby rails -n ~/alsomyproject # sets up RoR project named "alsomyproject" inside your home dir
DevAssistant also allows you to work with a previously created project, for example import it to Eclipse:
$ da mod eclipse # run in project dir or use -p to specify path
With DevAssistant, you can also prepare environment for developing upstream projects - either using project-specific assistants or using “custom” assistant for arbitrary projects (even those not created by DevAssistant):
$ da prep custom custom -u scm_url
Warning: The custom assistant executes custom pieces of code from .devassistant file of the project. Therefore you have to be extra careful and use this only with projects whose authors you trust.
Last but not least, DevAssistant allows you to perform arbitrary tasks not related to a specific project:
In short, assistant is a recipe for creating/modifying a project or setting up environment in a certain way. DevAssistant is in fact just a core that “runs” assistants according to certain rules.
Each assistant specifies a way how to achieve a single task, e.g. create a new project in framework X of language Y.
If you want to know more about how this all works, consult Yaml Assistant Reference.
There are four assistant roles:
The main purpose of having roles is separating different types of tasks. It would be confusing to have e.g. python django assistant (that creates new project) side-by-side with eclipse assistant (that registers existing project into Eclipse).
You can learn about how to invoke the respective roles below in Creating New Projects, Modifying Existing Projects and Preparing Environment.
DevAssistant can help you create (that’s the crt in the below command) your projects with one line in terminal. For example:
$ da crt python django -n foo -e -g
da is short form of devassistant. You can use any of them, but da is preferred.
This line will do the following:
DevAssistant allows you to work with previously created projects. You can do this by using da mod, as opposed to da crt for creating:
$ da mod eclipse
This will import previously created project into Eclipse (and possibly install Eclipse and other dependencies implied by the project language). Optionally, you can pass -p path/to/project if your current working directory is not the project directory.
DevAssistant can set up environment and install dependencies for development of already existing project located in a remote SCM (e.g. Github). For custom projects you can use the custom assistant. Note that for projects that don’t have .devassistant file, this will just checkout the sources:
$ da prep custom -u scm_url
Warning: The custom assistant executes custom pieces of code from .devassistant file, so use this only for projects whose upstreams you trust.
The plan is to also include assistants for well known and largely developed projects (that, of course, don’t contain .devassistant file). So in future you should be able to do something like:
$ da prep openstack
and it should do everything needed to get you started developing OpenStack in a way that others do. But this is still somewhere in the future...
The last piece of functionality is performing arbitrary tasks that are not related to a specific projects. E.g.:
$ da task <TODO:NOTHING YET>
There are also some custom actions besides crt, mod and prep. For the time being, these are not of high importance, but in future, these will bring more functionality, such as making coffee for you.
DevAssistant GUI provides the full functionality of Commandline Interface through a Gtk based application.
As opposed to CLI, which consists of three binaries, GUI provides all assistant types (creating, modifying, preparing) in one, each type having its own page.
The GUI workflow is dead simple:
Please note that list of currently supported assistants may vary greatly in different distributions, depending on available packages etc.
Currently supported assistants with their specialties (if any):
<TODO: NOTHING YET>