How to Create and Store a Symfony Project in SubversionEdit this page
Warning: You are browsing the documentation for Symfony 3.0, which is no longer maintained.
Read the updated version of this page for Symfony 6.1 (the current stable version).
This entry is specifically about Subversion, and based on principles found in How to Create and Store a Symfony Project in Git.
Once you've read through Create your First Page in Symfony and become familiar with using Symfony, you'll no-doubt be ready to start your own project. The preferred method to manage Symfony projects is using Git but some prefer to use Subversion which is totally fine!. In this article, you'll learn how to manage your project using SVN in a similar manner you would do with Git.
This is a method to tracking your Symfony project in a Subversion repository. There are several ways to do and this one is simply one that works.
For this article it's assumed that your repository layout follows the widespread standard structure:
1 2 3 4
myproject/ branches/ tags/ trunk/
Most Subversion hosting should follow this standard practice. This is the recommended layout in Version Control with Subversion and the layout used by most free hosting (see How to Create and Store a Symfony Project in Subversion).
To get started, you'll need to download Symfony and get the basic Subversion setup. First, download and get your Symfony project running by following the Installation chapter.
Once you have your new project directory and things are working, follow along with these steps:
Checkout the Subversion repository that will host this project. Suppose it is hosted on Google code and called
$ svn checkout http://myproject.googlecode.com/svn/trunk myproject
Copy the Symfony project files in the Subversion folder:
$ mv Symfony/* myproject/
Now, set the ignore rules. Not everything should be stored in your Subversion repository. Some files (like the cache) are generated and others (like the database configuration) are meant to be customized on each machine. This makes use of the
svn:ignoreproperty, so that specific files can be ignored.
1 2 3 4 5 6 7 8 9 10 11 12 13
$ cd myproject/ $ svn add --depth=empty app var var/cache var/logs app/config web $ svn propset svn:ignore "vendor" . $ svn propset svn:ignore "bootstrap*" var/ $ svn propset svn:ignore "parameters.yml" app/config/ $ svn propset svn:ignore "*" var/cache/ $ svn propset svn:ignore "*" var/logs/ $ svn propset svn:ignore "*" var/sessions/ $ svn propset svn:ignore "bundles" web $ svn ci -m "commit basic Symfony ignore list (vendor, var/bootstrap*, app/config/parameters.yml, var/cache/*, var/logs/*, web/bundles)"
The rest of the files can now be added and committed to the project:
$ svn add --force . $ svn ci -m "add basic Symfony Standard 3.X.Y"
That's it! Since the
app/config/parameters.yml file is ignored, you can
store machine-specific settings like database passwords here without committing
parameters.yml.dist file is committed, but is not read by
Symfony. And by adding any new keys you need to both files, new developers
can quickly clone the project, copy this file to
it, and start developing.
At this point, you have a fully-functional Symfony project stored in your Subversion repository. The development can start with commits in the Subversion repository.
You can continue to follow along with the Create your First Page in Symfony chapter to learn more about how to configure and develop inside your application.
The Symfony Standard Edition comes with some example functionality. To remove the sample code, follow the instructions in the "How to Remove a Bundle" article.
Every Symfony project uses a group of third-party "vendor" libraries. One
way or another the goal is to download these files into your
directory and, ideally, to give you some sane way to manage the exact version
you need for each.
By default, these libraries are downloaded by running a
"downloader" binary. This
composer file is from a library called Composer
and you can read more about installing it in the Installation
composer command reads from the
composer.json file at the root
of your project. This is an JSON-formatted file, which holds a list of each
of the external packages you need, the version to be downloaded and more.
composer also reads from a
composer.lock file, which allows you to
pin each library to an exact version. In fact, if a
file exists, the versions inside will override those in
To upgrade your libraries to new versions, run
If you want to add a new package to your application, run the composer
$ composer require doctrine/doctrine-fixtures-bundle
To learn more about Composer, see GetComposer.org:
It's important to realize that these vendor libraries are not actually part
of your repository. Instead, they're simply un-tracked files that are downloaded
vendor/. But since all the information needed to download these
files is saved in
composer.lock (which are stored
in the repository), any other developer can use the project, run
and download the exact same set of vendor libraries. This means that you're
controlling exactly what each vendor library looks like, without needing to
actually commit them to your repository.
So, whenever a developer uses your project, they should run the
script to ensure that all of the needed vendor libraries are downloaded.
- Self hosting: create your own repository and access it either through the filesystem or the network. To help in this task you can read Version Control with Subversion.
- Third party hosting: there are a lot of serious free hosting solutions available like GitHub, Google code, SourceForge or Gna. Some of them offer Git hosting as well.