The PHP reinassance

We have too much code

Takes less time to write a solution yourself than to find a component you can reuse.

Reusability

Sharing must be easy or it won't happen.

Free software as a feature.

First attemps, aka the way there

• Pear (PHP 4, required root, lots of includes)
• Class autoloading (PHP 5.0)
• Github (As replacement of Sourceforge)
• Namespaces (PHP 5.3)
• PHP standars (PSR-x)

Drush make (2010)

The shopping list

api = 2
core = 7.*
projects[views] = 3.1
projects[ctools] = 1.0-rc1
projects[media] = 2.x-dev

projects[nodequeue][subdir] = contrib
projects[nodequeue][version] = 2.0-alpha1
projects[nodequeue][patch][] = "http://drupal.org/files/issues/1023606-qid-to-name-6.patch"
projects[nodequeue][patch][] = "http://drupal.org/files/issues/nodequeue_d7_autocomplete-872444-6.patch"

libraries[jquery.cycle][download][type] = get
libraries[jquery.cycle][download][url] = http://malsup.com/jquery/cycle/release/jquery.cycle.zip?v2.99
libraries[jquery.cycle][destination] = libraries
          

Problems

• Downloads all the code everytime
• All dependencies listed
• You have to be specific about the versions
• Only remote patches
• Different make files for different purposes

The drupal island

Some brave sailors

Some brave sailors

Drupal makes some friends out there

Just by looking at the composer.json in drupal core

• A lot of symfony components(dependency injection, events, routing, yaml, etc)
• Twig
• Guzzle
• Composer
• And much more

Introducing Composer - 2012

The need

• 3rd party libraries.
• Dependency hell.
• Other PHP projects didn't had drush make.

Definition

Composer is a tool for dependency management in PHP. It allows you to declare the dependent libraries your project needs and it will install them in your project for you.

What it means

• No more Copy/Paste of libraries
• Resolves dependencies
• Each project defines its own requirements
• Performs build tasks
• Autoloading: all code under the same roof:

• Deps: You don't declare everything that is on your project. Only what you depend on.
• Build: Downloading of js libraries, binaries, cleaning, scaffolding, tests

Similar to composer in diferent programming languages

• npm (javascript)
• pip (python)
• rubygems (with bundler)

• Some are package managers and some are dependency managers or both

Get Composer

# Quick-n-easy:
$ curl -sS https://getcomposer.org/installer | php

# Global
$ curl -sS https://getcomposer.org/installer | php -- --install-dir=bin
            

Packagist.org

Main repository for packages. There is also https://packagist.drupal-composer.org/ as a mirror of the modules and themes on drupal.org

Require

            
composer require <vendor>/<package>
            
            

composer.json

Base manifest file for your project

{
    "name": "rodrigoaguilera/mydrupalsite",
    "description": "This site is awesome.",
    "require": {
        "drupal/honeypot": "8.1.*"
    },
    "require-dev": {
        "drupal/devel": "8.1.*"
    }
}
            

Composer.json vs composer.lock

Dependencies solved. Is the key for everyone to have the same versions. Always commit your lock file.

composer install

Reads composer.lock and downloads all your dependencies in the /vendor directory.

composer update

Writes a new composer.lock based on what is on composer.json and downloads what is needed You can update only one package to do more atomic updates.

Execute binaries

            
vendor/bin/drush
            
            

            
composer exec drush
            
            

Global vs local

The power of comes from having per project dependencies. but you can also install composer packages shared by everything and everyone. Use "composer global" before commands. (neeeds $COMPOSER_HOME)

Simulating enviroments

            
"config": {
    "platform": {
       "php": "5.6.2",
       "ext-mongodb": "1.1"
    }
}
            
            

Semantic versioning

Composer in production

            
composer install --prefer-dist --no-dev --optimize-autoloader
            
            

Component vs project

The composer.json for a project has more capabalities like:

• Use your own repos
• Define hook scripts

Patches

              
{
  "require": {
    "cweagans/composer-patches": "~1.0",
    "drupal/drupal": "8.0.*@dev"
  },
  "config": {
    "preferred-install": "source"
  },
  "extra": {
    "patches": {
      "drupal/drupal": {
        "Add startup configuration for PHP server": "https://www.drupal.org/files/issues/add_a_startup-1543858-30.patch"
      }
    }
  }
}
              
            

Install or update

• Make sure you have the last updates from other developers.
• Deploying a new release of your application to production.
• Checked out a new project and want to start coding.
• Grab new versions for the dependencies of your project.

But... How do I use composer in my drupal project?

Composer template for drupal projects comes to the rescue. https://github.com/drupal-composer/drupal-project

What does the template do?

• Drupal will be installed with correct permissions ready for install.
• Modules, themes, and profiles (packages of type drupal-[module|theme|profile]) will be placed in web/[module|theme|profile]/contrib/
• Creates default writable versions of settings.php and services.yml.
• Latest version of drush is installed locally for use at vendor/bin/drush.
• Latest version of DrupalConsole is installed locally for use at vendor/bin/drupal.

• Autoloader is implemented to use the generated composer autoloader instead of Drupal.
• separates scaffold files from the real drupal core
• Has a skeleton to put your drush aliases

Profit :D

• Now everyone can have not only the same modules but also drush and console
• Updating all your modules to the stable versions is just a couple of words away
• Your continous integration system can become much more simple