development with git and php (web development)

I’m struggling with the best approach to test php development code which is dependent on certain framework files to be present. I think there are three possible scenario’s with git:

  • Create a copy of the live production directory and clone this ‘dev’ directory to the local workstation. The next step would be to edit code on the local workstation and commit/push every change. You can check your work via the ‘dev’ url on the production server. If everything is alright you can push the changes to the ‘live’ directory. This approach may result in a lot of commits as you are editing/fixing your code (syntax errors or other obvious mistakes) and it adds an extra step (commit/push) to see your result.

  • How can I commit files with git?
  • Checkout A Project With Git And Visual Studio
  • Jenkins and updating git submodules
  • Failed to deploy to Github Pages using octopress
  • GIT Fetching Multiple Repository's
  • git rebase a single commit
  • Create a ‘dev’ server which mirrors the production server. This server will contain all the framework files and you’ll be able to edit a copy of the ‘live’ directory directly and immediately see your changes. If you prefer you can mount the remote ‘dev’ directory to your local workstation. This requires an extra server which needs to be maintained and you would need the resources to set it up.

  • Create a local ‘dev’ workstation environment and clone the repository on the ‘live’ or ‘dev’ server. This way you’ll be able to test all the code on your local machine and only push out the commits which have been tested and approved. This reduces the number of commits as opposed to method one. To recreate the ‘dev’ environment locally you might have to install a lot framework/dependent files to your local workstation and even then it might not be 100% reliable when the code is ported to the actual live server.

Basically I want to find the best method for the ‘write-test-revise-test-revise-test-commit’
cycle if you are dependent on framework files (whatever framework that may be). Would you create a ‘dev’ server or would you recreate the exact production environment on your local workstation? Ideally you would only commit the code when you have done some initial testing (obvious syntax errors etc.). A ‘dev’ server with local git repo would require that you commit every little change to test your work which may be tedious….

I hope I have made myself clear. I’m looking for the best way to integrate git and the ‘write-test-commit’ cycle. Normally you would test on the local machine but with web development you may need a webserver + framework to be able to test your code. Editing directly on the ‘live’ server is what I want to avoid.

Thanks for your input!

  • What are the pitfalls of “always” rebasing?
  • Remove local branches no longer on remote
  • Multiple Push URLs with Gitkraken
  • git-merge with repository on local filesystem
  • Git How do I Push a project, that was Downloaded from Source
  • Git stash silently hides/deletes staged changes
  • 2 Solutions collect form web for “development with git and php (web development)”

    There are definitely many ways to do this, but here is my 2 cents from how I have been working lately.

    First off, I would probably avoid a dev server per se, because if you have more than 1 developer, each developer may try to update the dev server with conflicting code, or if they are working on similar areas, overwrite some of your test code since you both probably are working from the same branch but have both modified the code and not yet pushed the changes.

    That said, you may want a dev server that closely resembles your live server so that after you and some of your other developers have made a number of changes, you can test them on the dev server before updating the code on the live server.

    In my environment, I develop on Linux and have Apache/PHP running the same versions and configs as the live server. This way, I clone my git repo, have my environment set up so that my document root is the “public” directory of my git repo (e.g. htdocs). In this case, we have a dev MySQL server which is usually shared, and not on the local machine, but you can do whatever is easiest there. Our system depends on constantly updated data from the field so this is why the shared database, we have a system which adds a lot of this necessary “test” data automatically to the database.

    This way, I can pull the latest code from git, work on it all I want, work-break-fix-work-work-work etc etc and when I have completed my task, I can push the changes back to git for other developers.

    When you are ready for a release, you can do all of your testing and stuff on the dev server, verify it is good to go and then push to the live.

    In my case for updating the “live” server, one person is responsible for that, and I use rsync to sync my local working directory to the live server. So when I am absolutely sure we are ready to deploy, I pull the most recent code from git, and run my script which rsyncs my git directory to the server.

    I’d avoid your methods 1 & 2, and go with something like 3. That will probably be the sanest thing for you to do and easiest to manage. Depending on what your team is like, you could create a dev VM that is pre-built with all the dependencies, correct software, and development tools you are all using, or leave it up to the developer to set themselves up.

    So far this method has worked pretty well for me and the others on my team.

    Call me opinionated, but every developer should have a local development AMP stack which they can develop against. If you don’t know how to set up an exact mirror of your production server, solve that problem first.

    Once you’re there, it should be trivial to have each developer set up a virtual machine with a clean OS install, configure web/php/db servers and libraries/framewroks to match the production environment, check out your project, and get to work.

    Developers commit against personal branches in their own local repos as they go, and after local testing, ship their code (via either a push, or a pull request, or whatever).

    The exact rules about how to merge changes into master depend on your team an preferences. But developers should almost always have a complete local dev environment. If it seems like it’s hard to set one up, that’s a big problem. Figure out how to make it easy and then document it.

    Git Baby is a git and github fan, let's start git clone.