Composer is a powerful dependency manager much like Bundler for

Ruby or NPM for Node.js.

All of these systems helped developers share code they have built and

implement shared code.

Composer works in a very similar way.

You can specify exact versions of the code that you would like to install.

This helps ensure that you don't accidentally get

major updates which could break your application, but still get bug fixes and

patch improvements when you run Composer update.

Composer is available from getcomposer.org.

When you click on the Getting Started link down here,

we can see installation instructions for popular operating systems.

Number five here, we have installation for

Windows, and at number four here, we have installation for *nix.

It's a bit of a, a bit of a confusing name, but it means that these

are the instructions for OS X, Linux, and any other Unix-based system.

We already have Composer installed in Workspaces, and

we can access it using the console feature.

If we go back to our workspace, we can take a look.

Now, we haven't used console before, but we can access it from View > Show Console.

You might recognize this as looking very similar to an OS X or

Linux terminal, and it is.

It works in very much the same way.

Now, from here, we can check that we have Composer installed just by

running the composer command.

If we see information like this, then it means it's installed.

Let's pretend for this lesson that we're building an application that requires

reading files from a ZIP file, and maybe in the future,

it also needs to support things like Amazon S3 or FTP drives.

That would be rather complicated to write ourselves, but luckily,

we can just install the Flysystem package from The League of Extraordinary Packages.

Now, to do that, we simply run composer require league/flysystem.

And what this will do, if there's no composer.json file already,

it will create one.

Otherwise, it will append to it.

But we don't have one, so we can assume it's going to create it.

When we run this, it will ask us which version we want.

Normally, it would be bad idea to specify any version at all, but for

now, it doesn't really matter and we can make it more specific later.

So we put star.

It just means, get me any version you can find.

[BLANK_AUDIO]

There we go. Looks like it's installed version 0.5.6.

And it's just suggesting a few other packages that we could install if we

wanted to, but we don't care about those.

So if we look with ls, we'll see we have some new files.

Let's refresh our workspace files and see what we've got.

So as I mentioned, a composer.json file has been created, and

inside we just have some basic JSOB with an array of stuff.

This array, we have require here, which is where we list all of our dependencies.

On the left, we have the names of our dependencies, and

on the right-hand side is the version.

So as I said, it's a little bit vague at the moment.

It's the version, but we know that it's installed 0.5.6.

So why don't we just say 0.5.*?

That means if updates come out, then it won't completely break our code.

Composer's also created a vendor folder with this autoload.php.

We'll look at that in a second.

Composer, which you don't need to look at.

This is some internal logic.

And it's created the league folder with our Flysystem package.

And this is where all the code for

Flysystem lives, especially in the source folder here.

So this is all the code that makes Flysystem run.

We haven't had to copy and paste anything or, or add anything.

It's just, it's just straight in there.

Finally, we can see a composer.lock file has been added.

This is similar in theory to the composer JSON file,

but it contains much more specific information.

Unfortunately, we can't preview it in Workspaces, but it contains information

like, was it installed from Git or was it downloaded from a ZIP file?

If it was downloaded, what was the exact checksum so

we can make sure that we are using the exact same version as each other.

You never want to edit the lock file, but whenever you want to compose a update,

.lock will be updated and you should commit the lock file.

So, with Composer installed and our new dependency Flysystem available to use,

let's have a look at how it all fits together.

[BLANK_AUDIO]

So, in previous versions, we made our own Bootstrap file,

which contained our own autoloader.

We don't need that anymore because we can just include the vendor autoload.php file

like we're doing on line three here.

This includes Composer's autoloader.

That means we don't have to worry about autoloading a tool.

As a side note, require is exactly the same as include,

with the added benefit of if it can't find the file, it will error.

So if you run your code and it says, line three failed, require could not

find vendor/autoload.php, then you know that you need to run composer install.

So, let's move this console down a little bit so we can look at our code better.

Okay, we've got some new stuff here.

On line seven, we have use League\Flysystem\Filesystem.

This avoids us having to reference the entire class name with all of

its namespace prefixed each time we use it.

We can now just reference Filesystem and PHP will know which class we mean.

On line eight, we have another use statement,

which lets us alias the Zip class to the global space.

This means we can reference Adapter and not Zip, which is a very common name and

might conflict with something else.

On line ten, we are instantiating an object as an instance of Filesystem,

containing an instance of Zip as a constructor.

That Zip class is then taking the location of the ZIP file as we want to read,

as a string argument, and that location is in the current directory /archive.zip.

Then, line 13 uses a Filesystem object method named listContents, and

we output everything into some HTML at the bottom.

This HTML makes an unordered list on line 24, and

proceeds to loop through on lines 25 to 27 down here.

This little for each will go through our contents, and

then make a content variable for each item it finds.

Finally, line 26 outputs a few values from the content array.

The type will say file or directory is a string.

And the path value will be the name and

location of the file inside our archive.zip.

So, let's run this and see what we get.

And there we have it.

A complex task made super easy just by installing a Composer package.