Composer

We have been talking about Object Orientation in PHP: How to define classes, invoke methods, etc.
We also talked about PHP's namespace mechanism which is similar to Java packages, and how the use namespace; declaration can be used together with a registered autoload callback function (registered via spl_autoload_register) to autoload classes.
Today, we begin by looking at a package manager for PHP that makes use of this autoloading mechanism.
Composer is a package management system for PHP. It was initially developed in 2011.
It lets people combine various PHP projects, making sure that the dependencies between the current project and different versions of the projects it depends are maintained.
A large list of projects that can be used with Composer can be found on the site: https://packagist.org/.
The Yioop search engine used for this class' discussion board is one such project.

Composer

The Composer site has instruction for downloading and installing composer.
Once it is downloaded, you can run it from the command line with a line like:
```
composer some_directive_for_composer
  
```
A composer project has at a minimum a composer.json file, and a sub-folder labeled vendor.
The composer.json file is used to specify what version of which projects your project depends on.
The vendor folder is where Composer downloads and stores the correct versions of these projects.

An example composer.json file suitable for working with Yioop is:

{
    "name": "your_vendor_name/your_project",
    "description": "put what your project is about here",
    "authors": [
        {
            "name": "Your Full Name",
            "email": "Where@to_contact.you"
        }
    ],
    "require": {
        "seekquarry/yioop": "dev-master"
    }
}

If you follow a folder structure within your project's src subfolder which matches the namespace after the vendor\project part, (for example, if the namespace\class was my_company\my_project\models\Model, and the class was in the file src/models/Model) then you can use the following composer.json file to get your classes to auto load:

{
    "name": "your_vendor_name/your_project",
    "description": "put what your project is about here",
    "authors": [
        {
            "name": "Your Full Name",
            "email": "Where@to_contact.you"
        }
    ],
    "require": {
// whatever the requires your project needs
    },
    "autoload": {
        "psr-4": {
            "my_company\\my_project\\": ["src/"]
        }
    }
}

psr-4 just refers to the above namespace to file path convention.

Example Composer Project Using Yioop

Once you've created a composer.json file and a blank vendor directory, you can start coding your project.
Typically, if you are using a version control system you add the vendor folder to your ignore list for the system. For example, with git, you might add the vendor folder to the .gitignore file.
In a standard project organization, you might then have an index.php file in the root folder of your project, have a src folder with the src code of your project and have a tests folder with any unit tests.

To keep things simple for our first try, we just put the following in our index.php file:

namespace cpollett\test_composer;

use seekquarry\yioop\configs as SYC;
use seekquarry\yioop\library as SYL;
use seekquarry\yioop\library\PhraseParser;

require_once "vendor/autoload.php";
print_r(PhraseParser::stemTerms("jumping", 'en-US'));
echo SYL\crawlHash(SYC\NAME_SERVER . "1234");

Then to get Composer to install Yioop under the vendor folder and create an autoloader for the projects that were needed, we might type from the project directory:
```
composer install
```
If you want to update composer projects later you type:
```
composer update
```
After which, we can run our program with the command:
```
php index.php
```
to execute out project. It should output:
```
Array
(
    [0] => jump
)
joQWpC4Sdy4
```

Comments on the Example

The example above illustrates using Yioop's PhraseParser class to do stemming.
This class can be found in the file YIOOP_FOLDER/src/library/PhraseParser.php.
This file has other useful methods for doing char-gramming, segmenting, and primitive detection of bad words.
Other file in the library folder, Utility.php contains lots of useful functions such as the crawlHash function illustrated above. For example, this file is where the functions for compressing/decompressing postings in Yioop are located.

Traits

Traits are a PHP language feature added in PHP 5.4, probably deriving from Python/Common Lisp mix-ins.

They allow one to define a collection of method implementations and then reuse them in several classes:

trait MyMethods 
{
    function getFoo() { /* code for getFoo */ }
    function getGoo() { /* code for getFoo */ }
}

class SomeClassA extends NeedsMethods 
{
    use MyMethods; //as if I had written the code in MyMethods here
    /* rest of SomeClassA code */
}

class SomeClassB extends NeedsMethods 
{
    use MyMethods;
    /* rest of SomeClassB code */
}

$a = new SomeClassA();
$a->getFoo();

You can import more that one trait by comma separating them:
```
class A  
{
   use MyMethodsA, MyMethodsB;
   // ...
}
```
Suppose both MyMethodsA and MyMethodsB define a function named foo and one named goo. This will result in a fatal error unless one explicitly resolves the conflict using the insteadof operation to say which to use, or uses the as operator to rename one:
```
use MyMethodsA, MyMethodsB {
    MyMethodsA::foo insteadof MyMethodsB;
    MyMethodsB::goo insteadof MyMethodsA;
    MyMethodsA::goo as gooey;
    MyMethodsB::foo as protected fooey; //notice can change visibility if want
}
```

In-Class Exercise

Write a PHP trait with a method foo() that echos "Mmmm foo!".
Create a class Goo that uses this trait and has a method what() which echos "What's foo?".
Write a program that instantiates Goo and calls foo() and what().
Post your solutions to the Oct 21 In-Class Exercise Thread.

Exceptions

PHP supports try catch blocks like Java.

try {} catch(MyException $e){} catch(Exception $ee){}

You can use the keyword throw to throw an exception

if($denom == 0){
    throw new Exception("divide by zero");
}

You can subclass Exception to create custom exceptions.

Generators

Generators are a PHP 5.5 feature that allow one to generate a sequence of values via function. They are similar to Python generators.
They are suitable for use in statements like foreach where the array argument might go.
Generator functions execute until a yield statement is reached.
This statement is like a return statement except that the context of the function is preserved. The next time the generator is called execution resumes in this context after where the yield statement was.

For example, in PHP, range(0, 10000) returns an array of elements 0 - 9999 which we could use in a foreach. A similar effect could be achieved with the code:

function my_gen($start, $end) {
    for ($i = $start; $i < $end; $i++) {
        // $i is preserved between yields.
        yield $i;
    }
}

$generator = my_gen(0, 10000);
foreach ($generator as $value) {
    echo "$value\n";
}

The advantage of the above code is that it uses less memory.
You can yield key value pairs with a syntax like:
```
yield $k => $v;
```
A yield statement without an argument returns a pair NUM_TIME_YIELD_CALLED => null.

Variable and Anonymous Functions

Variable functions are function calls using a variable. These are convenient to allow one to call methods based on parameters from a request. For example,

$action = $_REQUEST['a'];
$legal_actions = ['landing', 'write', 'read'];
if (in_array($action, $legal_actions)) {
    $action(); // here is the variable function
}

For methods you can use the syntax: $object->$method($arg);

PHP also supports anonymous functions and closures:

$salutation = function($name)
{
    echo "Hi there, " . $name;
}

$salutation('Chris');
$salutation('Bob');

/* To refer to values from the parent scope you can do:
   (i.e., this shows PHP has closures)
 */
$msg = 'there';

// Closures can also accept regular arguments
$example = function ($arg) use ($msg) {
    echo $arg . ' ' . $msg;
};
$example("hi");

This completes our initial pass at describing the PHP language.

Version Control Systems

A version control system solves the problem of how many people can work on the same code base at the same time.
It also serves as a proof of work which can be used in legal cases -- the history of versions proving the code did not materialize out of nowhere.
The oldest version control system is Source Code Control System developed at Bell Labs in 1972.
It was subsequently supplanted in popularity by RCS (Revision Control System) which in turn was supplanted by CVS (Concurrent Version System).
Nowadays, there are many different versions control systems on the market.
There are traditional central repository systems: CVS, Subversion (open source); BitKeeper, Perforce, ClearCase ( proprietary)
There are also distributed version control systems: Bazaar, git, Mercurial.
Here is a round-up of the different features of these systems http://en.wikipedia.org/wiki/Comparison_of_revision_control_software
Today, we are going to look at the git version control system as one means to manage our own projects. So we are going to be looking at a distributed VCS.
We will then talk about GitHub which is a web-site for hosting git repository. This central web-site and its features will give us a little bit of the flavor of how centralized repos work.
From Wikipedia, we can see GitHub far exceeds its nearest rival, Bitbucket in users (31 million versus 6 million).

Git

Git has been around since 2005, and was originally developed by Linus Torvalds, the creator of Linux.
Git has a nice website for publicly hosting git repositories known as GitHub. Repositories on this sites get their own issue tracker (with rss feed) and wiki.
To begin to set up a git repository move to where you would like to have your repository and type:
```
git init name_of_git_repository.
```
If you cd into this directory and do an ls -a to see hidden files, you will see a .git folder.
The .git folder keeps a complete copy of all prior commits down for this repository.
If you want to let someone to get a copy of your repository, you copy the repository folder on to a usb key (a key without Stuxnet please), give it to the person you want to have the repository.

The person that wants to get your repository, might have an existing repository that they want to get your stuff into or might be starting from scratch. They issue a commands like:

git clone path_to_clone_from to_folder #from scratch case
git pull path_to_from_repos branch_name_you_want_to_pull_into #existing case
git checkout branch #makes branch the current branch in the repository you are working on

Notice sharing can be done locally without the need for a central repository, you can zip your git folders and e-mail, git even has its own e-mail commands.
To see information about git commands, you can type 'git help', or 'git help command'

Composer, PHP Traits, Version Control, Git

Outline

Composer

Composer

Example Composer Project Using Yioop

Comments on the Example

Traits

In-Class Exercise

Exceptions

Generators

Variable and Anonymous Functions

Version Control Systems

Git